diff --git a/.eslintignore b/.eslintignore index 7b840476037..dfdddf739e8 100644 --- a/.eslintignore +++ b/.eslintignore @@ -41,4 +41,6 @@ /desktop/core/src/desktop/js/parse/sql/dasksql/dasksqlAutocompleteParser.js /desktop/core/src/desktop/js/parse/sql/dasksql/dasksqlSyntaxParser.js /desktop/core/src/desktop/js/parse/sql/dasksql/spec/dasksqlAutocompleteParser_Locations_Spec.js +/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.js +/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.js **/node_modules/** diff --git a/desktop/core/src/desktop/js/parse/sql/generic/jison/sql_main.test.json b/desktop/core/src/desktop/js/parse/sql/generic/jison/sql_main.test.json index 74e7eecd263..cd92738ae7f 100644 --- a/desktop/core/src/desktop/js/parse/sql/generic/jison/sql_main.test.json +++ b/desktop/core/src/desktop/js/parse/sql/generic/jison/sql_main.test.json @@ -1,11 +1,10 @@ [ { "namePrefix": "should suggest keywords", - "beforeCursor": ";;", + "beforeCursor": "[;;", "afterCursor": "", "containsKeywords": [ - "SELECT", - "WITH" + "SELECT" ], "expectedResult": { "lowerCase": false diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/jison/sql.jisonlex b/desktop/core/src/desktop/js/parse/sql/sparksql/jison/sql.jisonlex new file mode 100644 index 00000000000..0c010047c86 --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/jison/sql.jisonlex @@ -0,0 +1,229 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +%options case-insensitive flex +%s between +%x hdfs doubleQuotedValue singleQuotedValue backtickedValue +%% + +\s { /* skip whitespace */ } +'--'.* { /* skip comments */ } +[/][*][^*]*[*]+([^/*][^*]*[*]+)*[/] { /* skip comments */ } + +'\u2020' { parser.yy.partialCursor = false; parser.yy.cursorFound = yylloc; return 'CURSOR'; } +'\u2021' { parser.yy.partialCursor = true; parser.yy.cursorFound = yylloc; return 'PARTIAL_CURSOR'; } + +'AND' { this.popState(); return 'BETWEEN_AND'; } + +// Reserved Keywords +'ALL' { return 'ALL'; } +'ALTER' { parser.determineCase(yytext); parser.addStatementTypeLocation('ALTER', yylloc, yy.lexer.upcomingInput()); return 'ALTER'; } +'AND' { return 'AND'; } +'AS' { return 'AS'; } +'ASC' { return 'ASC'; } +'BETWEEN' { this.begin('between'); return 'BETWEEN'; } +'BIGINT' { return 'BIGINT'; } +'BOOLEAN' { return 'BOOLEAN'; } +'BY' { return 'BY'; } +'CASCADE' { return 'CASCADE'; } +'CASE' { return 'CASE'; } +'CHAR' { return 'CHAR'; } +'COLUMNS' { return 'COLUMNS'; } +'COMMENT' { return 'COMMENT'; } +'CREATE' { parser.determineCase(yytext); return 'CREATE'; } +'CROSS' { return 'CROSS'; } +'CURRENT' { return 'CURRENT'; } +'DATABASE' { return 'DATABASE'; } +'DECIMAL' { return 'DECIMAL'; } +'DESC' { return 'DESC'; } +'DISTINCT' { return 'DISTINCT'; } +'DIV' { return 'ARITHMETIC_OPERATOR'; } +'DOUBLE' { return 'DOUBLE'; } +'DROP' { parser.determineCase(yytext); parser.addStatementTypeLocation('DROP', yylloc, yy.lexer.upcomingInput()); return 'DROP'; } +'ELSE' { return 'ELSE'; } +'END' { return 'END'; } +'EXISTS' { parser.yy.correlatedSubQuery = true; return 'EXISTS'; } +'FALSE' { return 'FALSE'; } +'FLOAT' { return 'FLOAT'; } +'FOLLOWING' { return 'FOLLOWING'; } +'FROM' { parser.determineCase(yytext); return 'FROM'; } +'FULL' { return 'FULL'; } +'GROUP' { return 'GROUP'; } +'HAVING' { return 'HAVING'; } +'IF' { return 'IF'; } +'IN' { return 'IN'; } +'INNER' { return 'INNER'; } +'INSERT' { return 'INSERT'; } +'INT' { return 'INT'; } +'INTO' { return 'INTO'; } +'IS' { return 'IS'; } +'JOIN' { return 'JOIN'; } +'LEFT' { return 'LEFT'; } +'LIKE' { return 'LIKE'; } +'LIMIT' { return 'LIMIT'; } +'NOT' { return 'NOT'; } +'NULL' { return 'NULL'; } +'ON' { return 'ON'; } +'OPTION' { return 'OPTION'; } +'OR' { return 'OR'; } +'ORDER' { return 'ORDER'; } +'OUTER' { return 'OUTER'; } +'PARTITION' { return 'PARTITION'; } +'PRECEDING' { return 'PRECEDING'; } +'PURGE' { return 'PURGE'; } +'RANGE' { return 'RANGE'; } +'REGEXP' { return 'REGEXP'; } +'RIGHT' { return 'RIGHT'; } +'RLIKE' { return 'RLIKE'; } +'ROW' { return 'ROW'; } +'ROLE' { return 'ROLE'; } +'ROWS' { return 'ROWS'; } +'SCHEMA' { return 'SCHEMA'; } +'SCHEMAS' { return 'SCHEMAS'; } +'SELECT' { parser.determineCase(yytext); parser.addStatementTypeLocation('SELECT', yylloc); return 'SELECT'; } +'SEMI' { return 'SEMI'; } +'SET' { parser.determineCase(yytext); parser.addStatementTypeLocation('SET', yylloc); return 'SET'; } +'SHOW' { parser.determineCase(yytext); parser.addStatementTypeLocation('SHOW', yylloc); return 'SHOW'; } +'SMALLINT' { return 'SMALLINT'; } +'STRING' { return 'STRING'; } +'TABLE' { return 'TABLE'; } +'TABLES' { return 'TABLES'; } +'THEN' { return 'THEN'; } +'TIMESTAMP' { return 'TIMESTAMP'; } +'TINYINT' { return 'TINYINT'; } +'TO' { return 'TO'; } +'TRUE' { return 'TRUE'; } +'TRUNCATE' { parser.determineCase(yytext); parser.addStatementTypeLocation('TRUNCATE', yylloc, yy.lexer.upcomingInput()); return 'TRUNCATE'; } +'UNBOUNDED' { return 'UNBOUNDED'; } +'UNION' { return 'UNION'; } +'UPDATE' { parser.determineCase(yytext); return 'UPDATE'; } +'USE' { parser.determineCase(yytext); parser.addStatementTypeLocation('USE', yylloc); return 'USE'; } +'VALUES' { return 'VALUES'; } +'VARCHAR' { return 'VARCHAR'; } +'VIEW' { return 'VIEW'; } +'WHEN' { return 'WHEN'; } +'WHERE' { return 'WHERE'; } +'WITH' { parser.determineCase(yytext); parser.addStatementTypeLocation('WITH', yylloc); return 'WITH'; } + +// Non-reserved Keywords +'OVER' { return 'OVER'; } +'ROLE' { return 'ROLE'; } + +// --- UDFs --- +AVG\s*\( { yy.lexer.unput('('); yytext = 'avg'; parser.addFunctionLocation(yylloc, yytext); return 'AVG'; } +CAST\s*\( { yy.lexer.unput('('); yytext = 'cast'; parser.addFunctionLocation(yylloc, yytext); return 'CAST'; } +COUNT\s*\( { yy.lexer.unput('('); yytext = 'count'; parser.addFunctionLocation(yylloc, yytext); return 'COUNT'; } +MAX\s*\( { yy.lexer.unput('('); yytext = 'max'; parser.addFunctionLocation(yylloc, yytext); return 'MAX'; } +MIN\s*\( { yy.lexer.unput('('); yytext = 'min'; parser.addFunctionLocation(yylloc, yytext); return 'MIN'; } +STDDEV_POP\s*\( { yy.lexer.unput('('); yytext = 'stddev_pop'; parser.addFunctionLocation(yylloc, yytext); return 'STDDEV_POP'; } +STDDEV_SAMP\s*\( { yy.lexer.unput('('); yytext = 'stddev_samp'; parser.addFunctionLocation(yylloc, yytext); return 'STDDEV_SAMP'; } +SUM\s*\( { yy.lexer.unput('('); yytext = 'sum'; parser.addFunctionLocation(yylloc, yytext); return 'SUM'; } +VAR_POP\s*\( { yy.lexer.unput('('); yytext = 'var_pop'; parser.addFunctionLocation(yylloc, yytext); return 'VAR_POP'; } +VAR_SAMP\s*\( { yy.lexer.unput('('); yytext = 'var_samp'; parser.addFunctionLocation(yylloc, yytext); return 'VAR_SAMP'; } +VARIANCE\s*\( { yy.lexer.unput('('); yytext = 'variance'; parser.addFunctionLocation(yylloc, yytext); return 'VARIANCE'; } + +// Analytical functions +CUME_DIST\s*\( { yy.lexer.unput('('); yytext = 'cume_dist'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +DENSE_RANK\s*\( { yy.lexer.unput('('); yytext = 'dense_rank'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +FIRST_VALUE\s*\( { yy.lexer.unput('('); yytext = 'first_value'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +LAG\s*\( { yy.lexer.unput('('); yytext = 'lag'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +LAST_VALUE\s*\( { yy.lexer.unput('('); yytext = 'last_value'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +LEAD\s*\( { yy.lexer.unput('('); yytext = 'lead'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +RANK\s*\( { yy.lexer.unput('('); yytext = 'rank'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } +ROW_NUMBER\s*\( { yy.lexer.unput('('); yytext = 'row_number'; parser.addFunctionLocation(yylloc, yytext); return 'ANALYTIC'; } + +[0-9]+ { return 'UNSIGNED_INTEGER'; } +[0-9]+(?:[YSL]|BD)? { return 'UNSIGNED_INTEGER'; } +[0-9]+E { return 'UNSIGNED_INTEGER_E'; } +[A-Za-z0-9_]+ { return 'REGULAR_IDENTIFIER'; } + +'\u2020' { parser.yy.cursorFound = true; return 'CURSOR'; } +'\u2021' { parser.yy.cursorFound = true; return 'PARTIAL_CURSOR'; } +\s+['"] { return 'HDFS_START_QUOTE'; } +[^'"\u2020\u2021]+ { parser.addFileLocation(yylloc, yytext); return 'HDFS_PATH'; } +['"] { this.popState(); return 'HDFS_END_QUOTE'; } +<> { return 'EOF'; } + +'&&' { return 'AND'; } +'||' { return 'OR'; } + +'=' { return '='; } +'<' { return '<'; } +'>' { return '>'; } +'!=' { return 'COMPARISON_OPERATOR'; } +'<=' { return 'COMPARISON_OPERATOR'; } +'>=' { return 'COMPARISON_OPERATOR'; } +'<>' { return 'COMPARISON_OPERATOR'; } +'<=>' { return 'COMPARISON_OPERATOR'; } + +'-' { return '-'; } +'*' { return '*'; } +'+' { return 'ARITHMETIC_OPERATOR'; } +'/' { return 'ARITHMETIC_OPERATOR'; } +'%' { return 'ARITHMETIC_OPERATOR'; } +'|' { return 'ARITHMETIC_OPERATOR'; } +'^' { return 'ARITHMETIC_OPERATOR'; } +'&' { return 'ARITHMETIC_OPERATOR'; } + +',' { return ','; } +'.' { return '.'; } +':' { return ':'; } +';' { return ';'; } +'~' { return '~'; } +'!' { return '!'; } + +'(' { return '('; } +')' { return ')'; } +'[' { return '['; } +']' { return ']'; } + +\$\{[^}]*\} { return 'VARIABLE_REFERENCE'; } + +\` { this.begin('backtickedValue'); return 'BACKTICK'; } +[^`]+ { + if (parser.handleQuotedValueWithCursor(this, yytext, yylloc, '`')) { + return 'PARTIAL_VALUE'; + } + return 'VALUE'; + } +\` { this.popState(); return 'BACKTICK'; } + +\' { this.begin('singleQuotedValue'); return 'SINGLE_QUOTE'; } +(?:\\\\|\\[']|[^'])+ { + if (parser.handleQuotedValueWithCursor(this, yytext, yylloc, '\'')) { + return 'PARTIAL_VALUE'; + } + return 'VALUE'; + } +\' { this.popState(); return 'SINGLE_QUOTE'; } + +\" { this.begin('doubleQuotedValue'); return 'DOUBLE_QUOTE'; } +(?:\\\\|\\["]|[^"])+ { + if (parser.handleQuotedValueWithCursor(this, yytext, yylloc, '"')) { + return 'PARTIAL_VALUE'; + } + return 'VALUE'; + } +\" { this.popState(); return 'DOUBLE_QUOTE'; } + +<> { return 'EOF'; } + +. { /* To prevent console logging of unknown chars */ } +. { } +. { } +. { } +. { } +. { } diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/jison/structure.json b/desktop/core/src/desktop/js/parse/sql/sparksql/jison/structure.json new file mode 100644 index 00000000000..ee5e6b63a6e --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/jison/structure.json @@ -0,0 +1,74 @@ +{ + "lexer": "sql.jisonlex", + "autocomplete": [ + "../../generic/jison/autocomplete_header.jison", + "../../generic/jison/select/cte_select_statement.jison", + "../../generic/jison/select/from_clause.jison", + "../../generic/jison/select/group_by_clause.jison", + "../../generic/jison/select/having_clause.jison", + "../../generic/jison/select/joins.jison", + "../../generic/jison/select/limit_clause.jison", + "../../generic/jison/select/order_by_clause.jison", + "../../generic/jison/select/select.jison", + "../../generic/jison/select/select_conditions.jison", + "../../generic/jison/select/union_clause.jison", + "../../generic/jison/select/where_clause.jison", + "../../generic/jison/udf/aggregate/aggregate_common.jison", + "../../generic/jison/udf/aggregate/avg.jison", + "../../generic/jison/udf/aggregate/count.jison", + "../../generic/jison/udf/aggregate/max.jison", + "../../generic/jison/udf/aggregate/min.jison", + "../../generic/jison/udf/aggregate/stddev_pop.jison", + "../../generic/jison/udf/aggregate/stddev_samp.jison", + "../../generic/jison/udf/aggregate/sum.jison", + "../../generic/jison/udf/aggregate/var_pop.jison", + "../../generic/jison/udf/aggregate/var_samp.jison", + "../../generic/jison/udf/aggregate/variance.jison", + "../../generic/jison/udf/analytic/analytic.jison", + "../../generic/jison/udf/function/array.jison", + "../../generic/jison/udf/function/cast.jison", + "../../generic/jison/udf/function/if.jison", + "../../generic/jison/udf/function/map.jison", + "../../generic/jison/udf/function/truncate.jison", + "../../generic/jison/udf/udf_common.jison", + "../../generic/jison/sql_error.jison", + "../../generic/jison/sql_main.jison", + "../../generic/jison/sql_valueExpression.jison", + "../../generic/jison/autocomplete_footer.jison" + ], + "syntax": [ + "../../generic/jison/syntax_header.jison", + "../../generic/jison/select/cte_select_statement.jison", + "../../generic/jison/select/from_clause.jison", + "../../generic/jison/select/group_by_clause.jison", + "../../generic/jison/select/having_clause.jison", + "../../generic/jison/select/joins.jison", + "../../generic/jison/select/limit_clause.jison", + "../../generic/jison/select/order_by_clause.jison", + "../../generic/jison/select/select.jison", + "../../generic/jison/select/select_conditions.jison", + "../../generic/jison/select/union_clause.jison", + "../../generic/jison/select/where_clause.jison", + "../../generic/jison/udf/aggregate/aggregate_common.jison", + "../../generic/jison/udf/aggregate/avg.jison", + "../../generic/jison/udf/aggregate/count.jison", + "../../generic/jison/udf/aggregate/max.jison", + "../../generic/jison/udf/aggregate/min.jison", + "../../generic/jison/udf/aggregate/stddev_pop.jison", + "../../generic/jison/udf/aggregate/stddev_samp.jison", + "../../generic/jison/udf/aggregate/sum.jison", + "../../generic/jison/udf/aggregate/var_pop.jison", + "../../generic/jison/udf/aggregate/var_samp.jison", + "../../generic/jison/udf/aggregate/variance.jison", + "../../generic/jison/udf/analytic/analytic.jison", + "../../generic/jison/udf/function/array.jison", + "../../generic/jison/udf/function/cast.jison", + "../../generic/jison/udf/function/if.jison", + "../../generic/jison/udf/function/map.jison", + "../../generic/jison/udf/function/truncate.jison", + "../../generic/jison/udf/udf_common.jison", + "../../generic/jison/sql_main.jison", + "../../generic/jison/sql_valueExpression.jison", + "../../generic/jison/syntax_footer.jison" + ] +} \ No newline at end of file diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.Locations.test.js b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.Locations.test.js new file mode 100644 index 00000000000..989a32231e1 --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.Locations.test.js @@ -0,0 +1,1326 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// 'License'); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an 'AS IS' BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import sparksqlAutocompleteParser from './sparksqlAutocompleteParser'; + +// prettier-ignore-start +describe('sparksqlAutocompleteParser.js locations', () => { + beforeAll(() => { + sparksqlAutocompleteParser.yy.parseError = function (msg) { + throw Error(msg); + }; + }); + + const assertAutoComplete = testDefinition => { + const debug = false; + expect( + sparksqlAutocompleteParser.parseSql( + testDefinition.beforeCursor, + testDefinition.afterCursor, + debug + ) + ).toEqualDefinition(testDefinition); + }; + + const assertLocations = function (options) { + assertAutoComplete({ + beforeCursor: options.beforeCursor, + afterCursor: options.afterCursor || '', + locationsOnly: true, + noErrors: true, + expectedLocations: options.expectedLocations, + expectedDefinitions: options.expectedDefinitions + }); + }; + + it('should report locations for "select cos(1) as foo from customers order by foo;"', () => { + assertLocations({ + beforeCursor: 'select cos(1) as foo from customers order by foo; ', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 49 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 21 } + }, + { + type: 'function', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 10 }, + function: 'cos' + }, + { + type: 'functionArgument', + location: { first_line: 1, last_line: 1, first_column: 12, last_column: 13 }, + function: 'cos', + argumentPosition: 0, + identifierChain: [{ name: 'cos' }], + expression: { types: ['NUMBER'], text: '1' } + }, + { + type: 'alias', + source: 'column', + alias: 'foo', + location: { first_line: 1, last_line: 1, first_column: 18, last_column: 21 }, + parentLocation: { first_line: 1, last_line: 1, first_column: 8, last_column: 14 } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 27, last_column: 36 }, + identifierChain: [{ name: 'customers' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 36, last_column: 36 } + }, + { + type: 'alias', + location: { first_line: 1, last_line: 1, first_column: 46, last_column: 49 }, + alias: 'foo', + source: 'column', + parentLocation: { first_line: 1, last_line: 1, first_column: 8, last_column: 14 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 49, last_column: 49 } + } + ] + }); + }); + + it('should report locations for "WITH boo AS (SELECT * FROM tbl) SELECT * FROM boo; |"', () => { + assertLocations({ + beforeCursor: 'WITH boo AS (SELECT * FROM tbl) SELECT * FROM boo; ', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 50 } + }, + { + type: 'alias', + source: 'cte', + alias: 'boo', + location: { first_line: 1, last_line: 1, first_column: 6, last_column: 9 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 21, last_column: 22 }, + subquery: true + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 21, last_column: 22 }, + tables: [{ identifierChain: [{ name: 'tbl' }] }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 28, last_column: 31 }, + identifierChain: [{ name: 'tbl' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 31, last_column: 31 }, + subquery: true + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 31, last_column: 31 }, + subquery: true + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 40, last_column: 41 } + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 40, last_column: 41 }, + tables: [{ identifierChain: [{ name: 'boo' }] }] + }, + { + type: 'alias', + target: 'cte', + alias: 'boo', + location: { first_line: 1, last_line: 1, first_column: 47, last_column: 50 } + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 50, last_column: 50 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 50, last_column: 50 } + } + ] + }); + }); + + it('should report locations for "SELECT * FROM testTable1 JOIN db1.table2; |"', () => { + assertLocations({ + beforeCursor: 'SELECT * FROM testTable1 JOIN db1.table2; ', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 41 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 } + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + tables: [ + { identifierChain: [{ name: 'testTable1' }] }, + { identifierChain: [{ name: 'db1' }, { name: 'table2' }] } + ] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 25 }, + identifierChain: [{ name: 'testTable1' }] + }, + { + type: 'database', + location: { first_line: 1, last_line: 1, first_column: 31, last_column: 34 }, + identifierChain: [{ name: 'db1' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 35, last_column: 41 }, + identifierChain: [{ name: 'db1' }, { name: 'table2' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 41, last_column: 41 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 41, last_column: 41 } + } + ] + }); + }); + + it('should report locations for "SELECT a.col FROM db.tbl a; |"', () => { + assertLocations({ + beforeCursor: 'SELECT a.col FROM db.tbl a; ', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 27 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 13 } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + identifierChain: [{ name: 'db' }, { name: 'tbl' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 10, last_column: 13 }, + identifierChain: [{ name: 'col' }], + tables: [{ identifierChain: [{ name: 'db' }, { name: 'tbl' }], alias: 'a' }], + qualified: true + }, + { + type: 'database', + location: { first_line: 1, last_line: 1, first_column: 19, last_column: 21 }, + identifierChain: [{ name: 'db' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 22, last_column: 25 }, + identifierChain: [{ name: 'db' }, { name: 'tbl' }] + }, + { + type: 'alias', + source: 'table', + alias: 'a', + location: { first_line: 1, last_line: 1, first_column: 26, last_column: 27 }, + identifierChain: [{ name: 'db' }, { name: 'tbl' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 27, last_column: 27 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 27, last_column: 27 } + } + ] + }); + }); + + it('should report locations for "SELECT tbl.col FROM db.tbl a; |"', () => { + assertLocations({ + beforeCursor: 'SELECT tbl.col FROM db.tbl a; ', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 29 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 15 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 11 }, + identifierChain: [{ name: 'tbl' }], + tables: [{ identifierChain: [{ name: 'db' }, { name: 'tbl' }], alias: 'a' }], + qualified: false + }, + { + type: 'complex', + location: { first_line: 1, last_line: 1, first_column: 12, last_column: 15 }, + identifierChain: [{ name: 'tbl' }, { name: 'col' }], + tables: [{ identifierChain: [{ name: 'db' }, { name: 'tbl' }], alias: 'a' }], + qualified: true + }, + { + type: 'database', + location: { first_line: 1, last_line: 1, first_column: 21, last_column: 23 }, + identifierChain: [{ name: 'db' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 24, last_column: 27 }, + identifierChain: [{ name: 'db' }, { name: 'tbl' }] + }, + { + type: 'alias', + source: 'table', + alias: 'a', + location: { first_line: 1, last_line: 1, first_column: 28, last_column: 29 }, + identifierChain: [{ name: 'db' }, { name: 'tbl' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 29, last_column: 29 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 29, last_column: 29 } + } + ] + }); + }); + + it('should report locations for "select x from x;"', () => { + assertLocations({ + beforeCursor: 'select x from x;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 16 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + identifierChain: [{ name: 'x' }], + tables: [{ identifierChain: [{ name: 'x' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 16 }, + identifierChain: [{ name: 'x' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 16, last_column: 16 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 16, last_column: 16 } + } + ] + }); + }); + + it('should report locations for "select x from x;select y from y;"', () => { + assertLocations({ + beforeCursor: 'select x from x;select y from y;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 16 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + identifierChain: [{ name: 'x' }], + tables: [{ identifierChain: [{ name: 'x' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 16 }, + identifierChain: [{ name: 'x' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 16, last_column: 16 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 16, last_column: 16 } + }, + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 17, last_column: 32 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 24, last_column: 25 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 24, last_column: 25 }, + identifierChain: [{ name: 'y' }], + tables: [{ identifierChain: [{ name: 'y' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 31, last_column: 32 }, + identifierChain: [{ name: 'y' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 32, last_column: 32 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 32, last_column: 32 } + } + ] + }); + }); + + it('should report locations for "-- comment\nselect x from x;\n\n\nselect y from y;"', () => { + assertLocations({ + beforeCursor: '-- comment\nselect x from x;\n\n\nselect y from y;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 2, first_column: 1, last_column: 16 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 2, last_line: 2, first_column: 8, last_column: 9 } + }, + { + type: 'column', + location: { first_line: 2, last_line: 2, first_column: 8, last_column: 9 }, + identifierChain: [{ name: 'x' }], + tables: [{ identifierChain: [{ name: 'x' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 2, last_line: 2, first_column: 15, last_column: 16 }, + identifierChain: [{ name: 'x' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 2, last_line: 2, first_column: 16, last_column: 16 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 2, last_line: 2, first_column: 16, last_column: 16 } + }, + { + type: 'statement', + location: { first_line: 2, last_line: 5, first_column: 17, last_column: 16 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 5, last_line: 5, first_column: 8, last_column: 9 } + }, + { + type: 'column', + location: { first_line: 5, last_line: 5, first_column: 8, last_column: 9 }, + identifierChain: [{ name: 'y' }], + tables: [{ identifierChain: [{ name: 'y' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 5, last_line: 5, first_column: 15, last_column: 16 }, + identifierChain: [{ name: 'y' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 5, last_line: 5, first_column: 16, last_column: 16 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 5, last_line: 5, first_column: 16, last_column: 16 } + } + ] + }); + }); + + it('should report locations for "select x from x, y;"', () => { + assertLocations({ + beforeCursor: 'select x from x, y;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 19 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + identifierChain: [{ name: 'x' }], + tables: [{ identifierChain: [{ name: 'x' }] }, { identifierChain: [{ name: 'y' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 16 }, + identifierChain: [{ name: 'x' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 18, last_column: 19 }, + identifierChain: [{ name: 'y' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 19, last_column: 19 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 19, last_column: 19 } + } + ] + }); + }); + + it('should report locations for "SELECT t3.id, id FROM testTable1, db.testTable2, testTable3 t3;|"', () => { + assertLocations({ + beforeCursor: 'SELECT t3.id, id FROM testTable1, db.testTable2, testTable3 t3;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 63 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 17 } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 10 }, + identifierChain: [{ name: 'testTable3' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 11, last_column: 13 }, + identifierChain: [{ name: 'id' }], + tables: [{ identifierChain: [{ name: 'testTable3' }], alias: 't3' }], + qualified: true + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 17 }, + identifierChain: [{ name: 'id' }], + tables: [ + { identifierChain: [{ name: 'testTable1' }] }, + { identifierChain: [{ name: 'db' }, { name: 'testTable2' }] }, + { identifierChain: [{ name: 'testTable3' }], alias: 't3' } + ], + qualified: false + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 23, last_column: 33 }, + identifierChain: [{ name: 'testTable1' }] + }, + { + type: 'database', + location: { first_line: 1, last_line: 1, first_column: 35, last_column: 37 }, + identifierChain: [{ name: 'db' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 38, last_column: 48 }, + identifierChain: [{ name: 'db' }, { name: 'testTable2' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 50, last_column: 60 }, + identifierChain: [{ name: 'testTable3' }] + }, + { + type: 'alias', + source: 'table', + alias: 't3', + location: { first_line: 1, last_line: 1, first_column: 61, last_column: 63 }, + identifierChain: [{ name: 'testTable3' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 63, last_column: 63 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 63, last_column: 63 } + } + ] + }); + }); + + it('should report locations for "SELECT * FROM foo WHERE bar IN (1+1, 2+2);|"', () => { + assertLocations({ + beforeCursor: 'SELECT * FROM foo WHERE bar IN (1+1, 2+2);', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 42 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 } + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + tables: [{ identifierChain: [{ name: 'foo' }] }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 18 }, + identifierChain: [{ name: 'foo' }] + }, + { + type: 'whereClause', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 19, last_column: 42 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 25, last_column: 28 }, + identifierChain: [{ name: 'bar' }], + tables: [{ identifierChain: [{ name: 'foo' }] }], + qualified: false + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 42, last_column: 42 } + } + ] + }); + }); + + it('should report locations for "SELECT * FROM foo WHERE bar IN (id+1-1, id+1-2);|"', () => { + assertLocations({ + beforeCursor: 'SELECT * FROM foo WHERE bar IN (id+1-1, id+1-2);', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 48 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 } + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 9 }, + tables: [{ identifierChain: [{ name: 'foo' }] }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 15, last_column: 18 }, + identifierChain: [{ name: 'foo' }] + }, + { + type: 'whereClause', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 19, last_column: 48 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 25, last_column: 28 }, + identifierChain: [{ name: 'bar' }], + tables: [{ identifierChain: [{ name: 'foo' }] }], + qualified: false + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 33, last_column: 35 }, + identifierChain: [{ name: 'id' }], + tables: [{ identifierChain: [{ name: 'foo' }] }], + qualified: false + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 41, last_column: 43 }, + identifierChain: [{ name: 'id' }], + tables: [{ identifierChain: [{ name: 'foo' }] }], + qualified: false + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 48, last_column: 48 } + } + ] + }); + }); + + it( + 'should report locations for "SELECT s07.description, s07.salary, s08.salary,\\r\\n' + + ' s08.salary - s07.salary\\r\\n' + + 'FROM\\r\\n' + + ' sample_07 s07 JOIN sample_08 s08\\r\\n' + + 'ON ( s07.code = s08.code)\\r\\n' + + 'WHERE\\r\\n' + + ' s07.salary < s08.salary\\r\\n' + + 'ORDER BY s08.salary-s07.salary DESC\\r\\n' + + 'LIMIT 1000;|"', + () => { + assertLocations({ + beforeCursor: + 'SELECT s07.description, s07.salary, s08.salary,\r\n' + + ' s08.salary - s07.salary\r\n' + + 'FROM\r\n' + + ' sample_07 s07 JOIN sample_08 s08\r\n' + + 'ON ( s07.code = s08.code)\r\n' + + 'WHERE\r\n' + + ' s07.salary < s08.salary\r\n' + + 'ORDER BY s08.salary-s07.salary DESC\r\n' + + 'LIMIT 1000;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 9, first_column: 1, last_column: 11 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 2, first_column: 8, last_column: 26 } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 11 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 12, last_column: 23 }, + identifierChain: [{ name: 'description' }], + tables: [{ identifierChain: [{ name: 'sample_07' }], alias: 's07' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 25, last_column: 28 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 29, last_column: 35 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_07' }], alias: 's07' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 37, last_column: 40 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 41, last_column: 47 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_08' }], alias: 's08' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 2, last_line: 2, first_column: 3, last_column: 6 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'column', + location: { first_line: 2, last_line: 2, first_column: 7, last_column: 13 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_08' }], alias: 's08' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 2, last_line: 2, first_column: 16, last_column: 19 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'column', + location: { first_line: 2, last_line: 2, first_column: 20, last_column: 26 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_07' }], alias: 's07' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 4, last_line: 4, first_column: 3, last_column: 12 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'alias', + source: 'table', + alias: 's07', + location: { first_line: 4, last_line: 4, first_column: 13, last_column: 16 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'table', + location: { first_line: 4, last_line: 4, first_column: 22, last_column: 31 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'alias', + source: 'table', + alias: 's08', + location: { first_line: 4, last_line: 4, first_column: 32, last_column: 35 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'table', + location: { first_line: 5, last_line: 5, first_column: 6, last_column: 9 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'column', + location: { first_line: 5, last_line: 5, first_column: 10, last_column: 14 }, + identifierChain: [{ name: 'code' }], + tables: [{ identifierChain: [{ name: 'sample_07' }], alias: 's07' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 5, last_line: 5, first_column: 17, last_column: 20 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'column', + location: { first_line: 5, last_line: 5, first_column: 21, last_column: 25 }, + identifierChain: [{ name: 'code' }], + tables: [{ identifierChain: [{ name: 'sample_08' }], alias: 's08' }], + qualified: true + }, + { + type: 'whereClause', + missing: false, + location: { first_line: 6, last_line: 7, first_column: 1, last_column: 26 } + }, + { + type: 'table', + location: { first_line: 7, last_line: 7, first_column: 3, last_column: 6 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'column', + location: { first_line: 7, last_line: 7, first_column: 7, last_column: 13 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_07' }], alias: 's07' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 7, last_line: 7, first_column: 16, last_column: 19 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'column', + location: { first_line: 7, last_line: 7, first_column: 20, last_column: 26 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_08' }], alias: 's08' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 8, last_line: 8, first_column: 10, last_column: 13 }, + identifierChain: [{ name: 'sample_08' }] + }, + { + type: 'column', + location: { first_line: 8, last_line: 8, first_column: 14, last_column: 20 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_08' }], alias: 's08' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 8, last_line: 8, first_column: 21, last_column: 24 }, + identifierChain: [{ name: 'sample_07' }] + }, + { + type: 'column', + location: { first_line: 8, last_line: 8, first_column: 25, last_column: 31 }, + identifierChain: [{ name: 'salary' }], + tables: [{ identifierChain: [{ name: 'sample_07' }], alias: 's07' }], + qualified: true + }, + { + type: 'limitClause', + missing: false, + location: { first_line: 9, last_line: 9, first_column: 1, last_column: 11 } + } + ] + }); + } + ); + + it('should handle "select bl from blablabla join (select * from blablabla) s1;', () => { + assertLocations({ + beforeCursor: 'select bl from blablabla join (select * from blablabla) s1;', + afterCursor: '', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 59 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 10 } + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 10 }, + identifierChain: [{ name: 'bl' }], + tables: [{ identifierChain: [{ name: 'blablabla' }] }, { subQuery: 's1' }], + qualified: false + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 16, last_column: 25 }, + identifierChain: [{ name: 'blablabla' }] + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 39, last_column: 40 }, + subquery: true + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 39, last_column: 40 }, + tables: [{ identifierChain: [{ name: 'blablabla' }] }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 46, last_column: 55 }, + identifierChain: [{ name: 'blablabla' }] + }, + { + type: 'whereClause', + subquery: true, + missing: true, + location: { first_line: 1, last_line: 1, first_column: 55, last_column: 55 } + }, + { + type: 'limitClause', + subquery: true, + missing: true, + location: { first_line: 1, last_line: 1, first_column: 55, last_column: 55 } + }, + { + type: 'alias', + source: 'subquery', + alias: 's1', + location: { first_line: 1, last_line: 1, first_column: 57, last_column: 59 } + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 59, last_column: 59 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 59, last_column: 59 } + } + ] + }); + }); + + it( + 'should report locations for "SELECT CASE cos(boo.a) > baa.boo \\n' + + '\\tWHEN baa.b THEN true \\n' + + '\\tWHEN boo.c THEN false \\n' + + '\\tWHEN baa.blue THEN boo.d \\n' + + '\\tELSE baa.e END \\n' + + '\\t FROM db1.foo boo, bar baa WHERE baa.bla IN (SELECT ble FROM bla);|"', + () => { + assertLocations({ + beforeCursor: + 'SELECT CASE cos(boo.a) > baa.boo \n\tWHEN baa.b THEN true \n\tWHEN boo.c THEN false \n\tWHEN baa.blue THEN boo.d \n\tELSE baa.e END \n\t FROM db1.foo boo, bar baa WHERE baa.bla IN (SELECT ble FROM bla);', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 6, first_column: 1, last_column: 67 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 5, first_column: 8, last_column: 16 } + }, + { + type: 'function', + location: { first_line: 1, last_line: 1, first_column: 13, last_column: 15 }, + function: 'cos' + }, + { + type: 'functionArgument', + location: { first_line: 1, last_line: 1, first_column: 17, last_column: 22 }, + function: 'cos', + argumentPosition: 0, + identifierChain: [{ name: 'cos' }], + expression: { types: ['COLREF'], columnReference: [{ name: 'boo' }, { name: 'a' }] } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 17, last_column: 20 }, + identifierChain: [{ name: 'db1' }, { name: 'foo' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 21, last_column: 22 }, + identifierChain: [{ name: 'a' }], + tables: [{ identifierChain: [{ name: 'db1' }, { name: 'foo' }], alias: 'boo' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 26, last_column: 29 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'column', + location: { first_line: 1, last_line: 1, first_column: 30, last_column: 33 }, + identifierChain: [{ name: 'boo' }], + tables: [{ identifierChain: [{ name: 'bar' }], alias: 'baa' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 2, last_line: 2, first_column: 7, last_column: 10 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'column', + location: { first_line: 2, last_line: 2, first_column: 11, last_column: 12 }, + identifierChain: [{ name: 'b' }], + tables: [{ identifierChain: [{ name: 'bar' }], alias: 'baa' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 3, last_line: 3, first_column: 7, last_column: 10 }, + identifierChain: [{ name: 'db1' }, { name: 'foo' }] + }, + { + type: 'column', + location: { first_line: 3, last_line: 3, first_column: 11, last_column: 12 }, + identifierChain: [{ name: 'c' }], + tables: [{ identifierChain: [{ name: 'db1' }, { name: 'foo' }], alias: 'boo' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 4, last_line: 4, first_column: 7, last_column: 10 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'column', + location: { first_line: 4, last_line: 4, first_column: 11, last_column: 15 }, + identifierChain: [{ name: 'blue' }], + tables: [{ identifierChain: [{ name: 'bar' }], alias: 'baa' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 4, last_line: 4, first_column: 21, last_column: 24 }, + identifierChain: [{ name: 'db1' }, { name: 'foo' }] + }, + { + type: 'column', + location: { first_line: 4, last_line: 4, first_column: 25, last_column: 26 }, + identifierChain: [{ name: 'd' }], + tables: [{ identifierChain: [{ name: 'db1' }, { name: 'foo' }], alias: 'boo' }], + qualified: true + }, + { + type: 'table', + location: { first_line: 5, last_line: 5, first_column: 7, last_column: 10 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'column', + location: { first_line: 5, last_line: 5, first_column: 11, last_column: 12 }, + identifierChain: [{ name: 'e' }], + tables: [{ identifierChain: [{ name: 'bar' }], alias: 'baa' }], + qualified: true + }, + { + type: 'database', + location: { first_line: 6, last_line: 6, first_column: 8, last_column: 11 }, + identifierChain: [{ name: 'db1' }] + }, + { + type: 'table', + location: { first_line: 6, last_line: 6, first_column: 12, last_column: 15 }, + identifierChain: [{ name: 'db1' }, { name: 'foo' }] + }, + { + type: 'alias', + source: 'table', + alias: 'boo', + location: { first_line: 6, last_line: 6, first_column: 16, last_column: 19 }, + identifierChain: [{ name: 'db1' }, { name: 'foo' }] + }, + { + type: 'table', + location: { first_line: 6, last_line: 6, first_column: 21, last_column: 24 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'alias', + source: 'table', + alias: 'baa', + location: { first_line: 6, last_line: 6, first_column: 25, last_column: 28 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'whereClause', + missing: false, + location: { first_line: 6, last_line: 6, first_column: 29, last_column: 67 } + }, + { + type: 'table', + location: { first_line: 6, last_line: 6, first_column: 35, last_column: 38 }, + identifierChain: [{ name: 'bar' }] + }, + { + type: 'column', + location: { first_line: 6, last_line: 6, first_column: 39, last_column: 42 }, + identifierChain: [{ name: 'bla' }], + tables: [{ identifierChain: [{ name: 'bar' }], alias: 'baa' }], + qualified: true + }, + { + type: 'selectList', + missing: false, + location: { first_line: 6, last_line: 6, first_column: 54, last_column: 57 }, + subquery: true + }, + { + type: 'column', + location: { first_line: 6, last_line: 6, first_column: 54, last_column: 57 }, + identifierChain: [{ name: 'ble' }], + tables: [{ identifierChain: [{ name: 'bla' }] }], + qualified: false + }, + { + type: 'table', + location: { first_line: 6, last_line: 6, first_column: 63, last_column: 66 }, + identifierChain: [{ name: 'bla' }] + }, + { + type: 'whereClause', + subquery: true, + missing: true, + location: { first_line: 6, last_line: 6, first_column: 66, last_column: 66 } + }, + { + type: 'limitClause', + subquery: true, + missing: true, + location: { first_line: 6, last_line: 6, first_column: 66, last_column: 66 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 6, last_line: 6, first_column: 67, last_column: 67 } + } + ] + }); + } + ); + + it('should report locations for "SELECT tta.* FROM testTableA tta, testTableB; |"', () => { + assertLocations({ + beforeCursor: 'SELECT tta.* FROM testTableA tta, testTableB; ', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 45 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 13 } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 11 }, + identifierChain: [{ name: 'testTableA' }] + }, + { + type: 'asterisk', + location: { first_line: 1, last_line: 1, first_column: 12, last_column: 13 }, + tables: [{ alias: 'tta', identifierChain: [{ name: 'testTableA' }] }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 19, last_column: 29 }, + identifierChain: [{ name: 'testTableA' }] + }, + { + type: 'alias', + source: 'table', + alias: 'tta', + location: { first_line: 1, last_line: 1, first_column: 30, last_column: 33 }, + identifierChain: [{ name: 'testTableA' }] + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 35, last_column: 45 }, + identifierChain: [{ name: 'testTableB' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 45, last_column: 45 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 45, last_column: 45 } + } + ] + }); + }); + + it('should report locations for "SELECT COUNT(*) FROM testTable; |"', () => { + assertLocations({ + beforeCursor: 'SELECT COUNT(*) FROM testTable;', + expectedLocations: [ + { + type: 'statement', + location: { first_line: 1, last_line: 1, first_column: 1, last_column: 31 } + }, + { + type: 'selectList', + missing: false, + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 16 } + }, + { + type: 'function', + location: { first_line: 1, last_line: 1, first_column: 8, last_column: 12 }, + function: 'count' + }, + { + type: 'functionArgument', + location: { first_line: 1, last_line: 1, first_column: 14, last_column: 15 }, + function: 'count', + argumentPosition: 0, + identifierChain: [{ name: 'count' }], + expression: { text: '*' } + }, + { + type: 'table', + location: { first_line: 1, last_line: 1, first_column: 22, last_column: 31 }, + identifierChain: [{ name: 'testTable' }] + }, + { + type: 'whereClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 31, last_column: 31 } + }, + { + type: 'limitClause', + missing: true, + location: { first_line: 1, last_line: 1, first_column: 31, last_column: 31 } + } + ] + }); + }); +}); +// prettier-ignore-end diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.js b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.js new file mode 100644 index 00000000000..e71686f8933 --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.js @@ -0,0 +1,3469 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +/* parser generated by jison 0.4.17 */ +/* + Returns a Parser object of the following structure: + + Parser: { + yy: {} + } + + Parser.prototype: { + yy: {}, + trace: function(), + symbols_: {associative list: name ==> number}, + terminals_: {associative list: number ==> name}, + productions_: [...], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$), + table: [...], + defaultActions: {...}, + parseError: function(str, hash), + parse: function(input), + + lexer: { + EOF: 1, + parseError: function(str, hash), + setInput: function(input), + input: function(), + unput: function(str), + more: function(), + less: function(n), + pastInput: function(), + upcomingInput: function(), + showPosition: function(), + test_match: function(regex_match_array, rule_index), + next: function(), + lex: function(), + begin: function(condition), + popState: function(), + _currentRules: function(), + topState: function(), + pushState: function(condition), + + options: { + ranges: boolean (optional: true ==> token location info will include a .range[] member) + flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match) + backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code) + }, + + performAction: function(yy, yy_, $avoiding_name_collisions, YY_START), + rules: [...], + conditions: {associative list: name ==> set}, + } + } + + + token location info (@$, _$, etc.): { + first_line: n, + last_line: n, + first_column: n, + last_column: n, + range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based) + } + + + the parseError function receives a 'hash' object with these members for lexer and parser errors: { + text: (matched text) + token: (the produced terminal token, if any) + line: (yylineno) + } + while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: { + loc: (yylloc) + expected: (string describing the set of expected tokens) + recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error) + } +*/ +import SqlParseSupport from 'parse/sql/sparksql/sqlParseSupport'; + +var sparksqlAutocompleteParser = (function(){ +var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[2,7,8,13,17,20,22,27,35,36,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,90,99,100,106,115,117,141,142,143,144,145,146,147,148,149,150,151,153,154,155,157,163,171,177,179,180,181,185,187,194,197,198,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,263],$V1=[2,363],$V2=[177,194],$V3=[2,335],$V4=[1,5],$V5=[1,10],$V6=[1,11],$V7=[1,129],$V8=[1,13],$V9=[1,27],$Va=[1,127],$Vb=[1,54],$Vc=[1,56],$Vd=[1,34],$Ve=[1,57],$Vf=[1,40],$Vg=[1,65],$Vh=[1,55],$Vi=[1,78],$Vj=[1,61],$Vk=[1,66],$Vl=[1,92],$Vm=[1,86],$Vn=[1,74],$Vo=[1,68],$Vp=[1,113],$Vq=[1,77],$Vr=[1,28],$Vs=[1,44],$Vt=[1,132],$Vu=[1,22],$Vv=[1,45],$Vw=[1,12],$Vx=[1,106],$Vy=[1,116],$Vz=[1,29],$VA=[1,70],$VB=[1,71],$VC=[1,96],$VD=[1,97],$VE=[1,110],$VF=[1,111],$VG=[1,114],$VH=[1,39],$VI=[1,100],$VJ=[1,23],$VK=[1,26],$VL=[1,59],$VM=[1,69],$VN=[1,36],$VO=[1,73],$VP=[1,79],$VQ=[1,122],$VR=[1,123],$VS=[1,125],$VT=[1,93],$VU=[1,17],$VV=[1,117],$VW=[1,118],$VX=[1,88],$VY=[1,75],$VZ=[1,99],$V_=[1,85],$V$=[1,9],$V01=[1,14],$V11=[1,15],$V21=[1,16],$V31=[1,18],$V41=[1,19],$V51=[1,20],$V61=[1,21],$V71=[1,24],$V81=[1,25],$V91=[1,30],$Va1=[1,31],$Vb1=[1,32],$Vc1=[1,33],$Vd1=[1,35],$Ve1=[1,37],$Vf1=[1,38],$Vg1=[1,41],$Vh1=[1,42],$Vi1=[1,43],$Vj1=[1,46],$Vk1=[1,47],$Vl1=[1,48],$Vm1=[1,49],$Vn1=[1,50],$Vo1=[1,51],$Vp1=[1,52],$Vq1=[1,53],$Vr1=[1,58],$Vs1=[1,60],$Vt1=[1,62],$Vu1=[1,63],$Vv1=[1,64],$Vw1=[1,67],$Vx1=[1,72],$Vy1=[1,76],$Vz1=[1,80],$VA1=[1,81],$VB1=[1,82],$VC1=[1,83],$VD1=[1,84],$VE1=[1,87],$VF1=[1,89],$VG1=[1,90],$VH1=[1,91],$VI1=[1,94],$VJ1=[1,95],$VK1=[1,98],$VL1=[1,101],$VM1=[1,102],$VN1=[1,103],$VO1=[1,104],$VP1=[1,105],$VQ1=[1,107],$VR1=[1,108],$VS1=[1,109],$VT1=[1,112],$VU1=[1,115],$VV1=[1,128],$VW1=[1,141],$VX1=[8,177,194],$VY1=[2,213],$VZ1=[1,149],$V_1=[2,487],$V$1=[1,158],$V02=[1,160],$V12=[1,161],$V22=[1,162],$V32=[1,157],$V42=[1,156],$V52=[2,8,177,194],$V62=[1,165],$V72=[1,168],$V82=[2,161],$V92=[1,170],$Va2=[1,171],$Vb2=[2,7,8,13,17,20,27,35,36,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,90,99,100,106,115,117,141,142,143,144,145,146,147,148,149,150,151,153,154,155,157,163,171,177,185,187,194,197,198,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261],$Vc2=[2,214],$Vd2=[2,8,115,177,194],$Ve2=[2,12],$Vf2=[2,7,8,90,177,194],$Vg2=[2,7,8,17,22,90,177,194],$Vh2=[2,7,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,206,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$Vi2=[1,189],$Vj2=[1,188],$Vk2=[1,193],$Vl2=[1,207],$Vm2=[1,217],$Vn2=[1,206],$Vo2=[1,265],$Vp2=[1,266],$Vq2=[1,267],$Vr2=[1,268],$Vs2=[1,269],$Vt2=[1,270],$Vu2=[1,271],$Vv2=[1,272],$Vw2=[1,256],$Vx2=[1,257],$Vy2=[1,246],$Vz2=[1,229],$VA2=[1,230],$VB2=[1,231],$VC2=[1,232],$VD2=[1,247],$VE2=[1,224],$VF2=[1,208],$VG2=[1,213],$VH2=[1,215],$VI2=[1,274],$VJ2=[1,214],$VK2=[1,218],$VL2=[1,277],$VM2=[1,216],$VN2=[1,279],$VO2=[1,212],$VP2=[1,276],$VQ2=[1,278],$VR2=[1,273],$VS2=[1,275],$VT2=[2,7,8,17,22,77,90,106,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,183,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258,263],$VU2=[2,7,8,17,90,177,194],$VV2=[1,307],$VW2=[1,317],$VX2=[1,318],$VY2=[1,314],$VZ2=[1,315],$V_2=[1,303],$V$2=[1,305],$V03=[1,304],$V13=[1,308],$V23=[1,320],$V33=[1,306],$V43=[1,302],$V53=[1,319],$V63=[8,115,177,194],$V73=[2,147],$V83=[1,329],$V93=[1,323],$Va3=[1,334],$Vb3=[1,337],$Vc3=[1,344],$Vd3=[1,338],$Ve3=[1,339],$Vf3=[1,340],$Vg3=[1,343],$Vh3=[1,345],$Vi3=[1,341],$Vj3=[1,348],$Vk3=[1,347],$Vl3=[1,342],$Vm3=[1,350],$Vn3=[1,349],$Vo3=[2,8,17,22,27,95,115,177,194],$Vp3=[2,345],$Vq3=[2,8,27,115,177,194],$Vr3=[2,830],$Vs3=[1,373],$Vt3=[1,367],$Vu3=[1,357],$Vv3=[1,366],$Vw3=[1,358],$Vx3=[1,359],$Vy3=[1,365],$Vz3=[1,368],$VA3=[1,379],$VB3=[1,363],$VC3=[1,360],$VD3=[1,362],$VE3=[1,356],$VF3=[1,376],$VG3=[1,361],$VH3=[1,364],$VI3=[1,378],$VJ3=[1,377],$VK3=[2,184],$VL3=[17,27],$VM3=[2,8,17,27,115,177,194],$VN3=[1,399],$VO3=[1,396],$VP3=[1,386],$VQ3=[1,395],$VR3=[1,387],$VS3=[1,388],$VT3=[1,394],$VU3=[1,397],$VV3=[1,392],$VW3=[1,389],$VX3=[1,391],$VY3=[1,390],$VZ3=[1,393],$V_3=[1,400],$V$3=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$V04=[1,407],$V14=[1,411],$V24=[1,417],$V34=[1,428],$V44=[1,431],$V54=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,237,238,239,244,245,249,253,261,326],$V64=[2,298],$V74=[1,434],$V84=[2,7,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$V94=[2,757],$Va4=[2,327],$Vb4=[1,442],$Vc4=[1,447],$Vd4=[2,7,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,206,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$Ve4=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,171,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$Vf4=[1,458],$Vg4=[1,457],$Vh4=[1,461],$Vi4=[1,460],$Vj4=[1,463],$Vk4=[1,470],$Vl4=[13,90],$Vm4=[2,808],$Vn4=[2,8],$Vo4=[1,489],$Vp4=[1,479],$Vq4=[1,488],$Vr4=[1,480],$Vs4=[1,481],$Vt4=[1,487],$Vu4=[1,490],$Vv4=[1,485],$Vw4=[1,482],$Vx4=[1,484],$Vy4=[1,478],$Vz4=[1,483],$VA4=[1,486],$VB4=[1,495],$VC4=[1,499],$VD4=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$VE4=[1,500],$VF4=[8,35,50,75,81,115,177,194],$VG4=[2,226],$VH4=[2,8,35,50,75,81,115,177,194],$VI4=[1,524],$VJ4=[1,550],$VK4=[1,567],$VL4=[100,163,229,256],$VM4=[2,784],$VN4=[2,8,17,22,27,35,50,63,64,65,66,67,68,69,70,71,75,81,95,115,117,177,194],$VO4=[2,8,17,27,35,50,63,64,65,66,67,68,69,70,71,75,81,115,117,177,194],$VP4=[1,619],$VQ4=[1,628],$VR4=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,194,200,201,202,203,212,214,215,225,226,227,238,239,243,247,249,253,261,326],$VS4=[2,626],$VT4=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,115,117,177,194,200,201,202,203,212,214,215,225,226,227,238,239,249,253,261,326],$VU4=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,115,117,177,194,200,201,202,203,205,212,214,215,225,226,227,233,238,239,249,253,261,326],$VV4=[1,644],$VW4=[2,627],$VX4=[2,628],$VY4=[1,645],$VZ4=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,238,239,243,247,249,253,261,326],$V_4=[2,629],$V$4=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,238,239,249,253,261,326],$V05=[1,650],$V15=[1,653],$V25=[1,652],$V35=[1,664],$V45=[1,660],$V55=[1,663],$V65=[1,662],$V75=[1,667],$V85=[2,22,226,227,261],$V95=[2,226,227],$Va5=[1,680],$Vb5=[1,686],$Vc5=[1,687],$Vd5=[1,690],$Ve5=[1,697],$Vf5=[1,702],$Vg5=[1,708],$Vh5=[1,707],$Vi5=[1,711],$Vj5=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$Vk5=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,237,238,239,244,245,249,253,261,326],$Vl5=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,194,200,201,202,203,212,214,215,225,226,227,238,239,243,247,249,253,261,326],$Vm5=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,238,239,243,247,249,253,261,326],$Vn5=[7,77,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258],$Vo5=[2,346],$Vp5=[2,8,35,50,63,64,65,66,67,68,69,70,75,81,115,177,194],$Vq5=[2,68],$Vr5=[1,778],$Vs5=[1,781],$Vt5=[1,779],$Vu5=[1,783],$Vv5=[1,780],$Vw5=[1,782],$Vx5=[1,785],$Vy5=[1,784],$Vz5=[8,50,75,81,115,177,194],$VA5=[2,34],$VB5=[1,789],$VC5=[2,8,50,63,64,65,66,67,68,69,70,75,81,115,177,194],$VD5=[1,792],$VE5=[2,227],$VF5=[2,24],$VG5=[2,8,35,50,75,81,115,117,177,194],$VH5=[2,8,17,22,35,50,75,81,115,117,177,194],$VI5=[2,8,17,35,50,75,81,115,117,177,194],$VJ5=[8,17,22,35,50,75,81,115,117,177,194],$VK5=[2,788],$VL5=[1,808],$VM5=[1,809],$VN5=[1,812],$VO5=[1,810],$VP5=[1,811],$VQ5=[1,814],$VR5=[1,813],$VS5=[2,8,17,22,35,50,63,64,65,66,67,68,69,70,71,75,81,115,117,177,194],$VT5=[2,8,17,35,50,63,64,65,66,67,68,69,70,71,75,81,115,117,177,194],$VU5=[2,8,17,20,22,35,50,63,64,65,66,67,68,69,70,71,75,77,81,115,117,177,194,200,201,202,203,214,225,249],$VV5=[2,8,17,20,35,50,63,64,65,66,67,68,69,70,71,75,77,81,115,117,177,194,200,201,202,203,214,225,249],$VW5=[2,558],$VX5=[1,825],$VY5=[2,892],$VZ5=[2,893],$V_5=[2,894],$V$5=[1,829],$V06=[2,348],$V16=[1,830],$V26=[1,832],$V36=[1,831],$V46=[2,785],$V56=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,187,194,200,201,202,203,207,208,212,214,215,220,225,226,227,238,239,243,247,249,253,261,326],$V66=[2,636],$V76=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,115,117,177,187,194,200,201,202,203,207,208,212,214,215,220,225,226,227,238,239,249,253,261,326],$V86=[2,637],$V96=[2,638],$Va6=[2,639],$Vb6=[1,850],$Vc6=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,115,117,177,194,200,201,202,203,205,212,214,215,225,226,227,233,239,249,253,261,326],$Vd6=[2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,194,200,201,202,203,212,214,225,226,227,239,243,247,249,253,261,326],$Ve6=[2,646],$Vf6=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,115,117,177,194,200,201,202,203,212,214,225,226,227,239,249,253,261,326],$Vg6=[2,647],$Vh6=[2,648],$Vi6=[2,649],$Vj6=[2,650],$Vk6=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,106,115,117,177,187,194,200,201,202,203,205,206,207,208,212,213,214,215,220,225,226,227,233,237,238,239,244,245,249,253,261,326],$Vl6=[2,7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,90,106,115,117,171,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,237,238,239,244,245,249,253,261,326],$Vm6=[1,867],$Vn6=[2,226,227,261],$Vo6=[1,887],$Vp6=[1,889],$Vq6=[1,891],$Vr6=[8,17,22],$Vs6=[2,314],$Vt6=[8,81],$Vu6=[2,845],$Vv6=[1,902],$Vw6=[22,171],$Vx6=[1,903],$Vy6=[1,914],$Vz6=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,187,194,200,201,202,203,207,208,212,214,215,220,225,226,227,238,239,243,247,249,253,261,326],$VA6=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,194,200,201,202,203,212,214,225,226,227,239,243,247,249,253,261,326],$VB6=[1,937],$VC6=[2,8,17],$VD6=[1,951],$VE6=[1,952],$VF6=[1,954],$VG6=[2,7,8,22,63,64,65,66,67,68,69,70,77,115,177,194,200,201,202,203,214],$VH6=[1,956],$VI6=[1,959],$VJ6=[1,961],$VK6=[1,964],$VL6=[8,75,81,115,177,194],$VM6=[2,63],$VN6=[1,968],$VO6=[2,8,63,64,65,66,67,68,69,70,75,81,115,177,194],$VP6=[1,971],$VQ6=[2,35],$VR6=[2,231],$VS6=[2,792],$VT6=[1,991],$VU6=[2,8,17,35,50,63,64,65,66,67,68,69,70,75,81,115,117,177,194],$VV6=[1,1022],$VW6=[1,1023],$VX6=[1,1024],$VY6=[1,1028],$VZ6=[8,17,22,81],$V_6=[2,742],$V$6=[2,8,81],$V07=[1,1039],$V17=[2,8,17,81],$V27=[1,1045],$V37=[1,1059],$V47=[2,851],$V57=[1,1071],$V67=[1,1074],$V77=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,106,115,117,171,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,237,238,239,244,245,249,253,261,326],$V87=[1,1082],$V97=[1,1083],$Va7=[1,1084],$Vb7=[1,1085],$Vc7=[1,1086],$Vd7=[1,1087],$Ve7=[1,1088],$Vf7=[1,1089],$Vg7=[1,1090],$Vh7=[1,1091],$Vi7=[1,1092],$Vj7=[1,1093],$Vk7=[1,1101],$Vl7=[1,1105],$Vm7=[1,1109],$Vn7=[1,1121],$Vo7=[2,349],$Vp7=[2,116],$Vq7=[1,1124],$Vr7=[1,1125],$Vs7=[1,1126],$Vt7=[1,1127],$Vu7=[1,1128],$Vv7=[1,1129],$Vw7=[1,1130],$Vx7=[1,1131],$Vy7=[8,75,115,177,194],$Vz7=[2,129],$VA7=[2,8,63,64,65,66,67,68,69,70,75,115,177,194],$VB7=[2,64],$VC7=[75,81],$VD7=[8,17,22,35,50,63,64,65,66,67,68,69,70,75,81,115,117,177,194],$VE7=[1,1165],$VF7=[2,7,8,17,35,50,63,64,65,66,67,68,69,70,75,77,81,115,117,177,194,200,201,202,203,214],$VG7=[2,347],$VH7=[1,1188],$VI7=[1,1196],$VJ7=[2,645],$VK7=[2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,115,117,177,194,200,201,202,203,212,214,215,225,226,227,239,249,253,261,326],$VL7=[2,923],$VM7=[2,315],$VN7=[2,856],$VO7=[1,1218],$VP7=[1,1217],$VQ7=[2,620],$VR7=[1,1233],$VS7=[2,8,17,22,35,50,63,64,65,66,67,68,69,70,75,81,115,117,177,194],$VT7=[2,122],$VU7=[2,8,63,64,65,66,67,68,69,70,115,177,194],$VV7=[1,1253],$VW7=[2,130],$VX7=[2,65],$VY7=[2,36],$VZ7=[2,8,17,22,50,75,81,115,177,194],$V_7=[2,51],$V$7=[1,1271],$V08=[2,8,17,50,63,64,65,66,67,68,69,70,75,81,115,177,194],$V18=[2,633],$V28=[2,644],$V38=[2,743],$V48=[22,215,383],$V58=[2,847],$V68=[2,117],$V78=[2,123],$V88=[1,1313],$V98=[1,1315],$Va8=[1,1319],$Vb8=[8,22,212,221,257,383],$Vc8=[2,866],$Vd8=[2,131],$Ve8=[2,8,17,22,63,64,65,66,67,68,69,70,75,115,177,194,243,247],$Vf8=[2,144],$Vg8=[1,1348],$Vh8=[1,1349],$Vi8=[2,8,17,63,64,65,66,67,68,69,70,75,115,177,194],$Vj8=[2,8,212,221,257,383],$Vk8=[1,1354],$Vl8=[2,8,22,63,64,65,66,67,68,69,70,115,177,194],$Vm8=[2,52],$Vn8=[8,22,212],$Vo8=[2,876],$Vp8=[1,1370],$Vq8=[1,1371],$Vr8=[1,1372],$Vs8=[2,8,212],$Vt8=[1,1379],$Vu8=[2,881],$Vv8=[1,1390],$Vw8=[1,1391],$Vx8=[1,1393],$Vy8=[22,231,241],$Vz8=[2,858],$VA8=[2,8,22,212],$VB8=[1,1407],$VC8=[1,1409],$VD8=[2,8,22]; +var parser = {trace: function trace () { }, +yy: {}, +symbols_: {"error":2,"QuerySpecification":3,"CommonTableExpression":4,"SelectStatement":5,"OptionalUnions":6,"(":7,")":8,"QuerySpecification_EDIT":9,"SelectStatement_EDIT":10,"OptionalUnions_EDIT":11,"CommonTableExpression_EDIT":12,"WITH":13,"WithQueries":14,"WithQueries_EDIT":15,"WithQuery":16,",":17,"WithQuery_EDIT":18,"RegularOrBacktickedIdentifier":19,"AS":20,"TableSubQueryInner":21,"CURSOR":22,"AnyCursor":23,"RightParenthesisOrError":24,"TableSubQueryInner_EDIT":25,"FromClause":26,"FROM":27,"TableReferenceList":28,"FromClause_EDIT":29,"TableReferenceList_EDIT":30,"TableReference":31,"TableReference_EDIT":32,"OptionalGroupByClause":33,"GroupByClause":34,"GROUP":35,"BY":36,"GroupByColumnList":37,"GroupByClause_EDIT":38,"GroupByColumnList_EDIT":39,"ColumnGroupingSets":40,"ColumnReference":41,"ColumnGroupingSets_EDIT":42,"ColumnGroupingSet_EDIT":43,"ColumnReference_EDIT":44,"ValueExpression":45,"ValueExpression_EDIT":46,"GroupByColumnListPartTwo_EDIT":47,"OptionalHavingClause":48,"HavingClause":49,"HAVING":50,"HavingClause_EDIT":51,"OptionalJoins":52,"Joins":53,"Joins_INVALID":54,"JoinType":55,"TablePrimary":56,"OptionalJoinCondition":57,"Join_EDIT":58,"JoinType_EDIT":59,"TablePrimary_EDIT":60,"JoinCondition_EDIT":61,"Joins_EDIT":62,"CROSS":63,"JOIN":64,"FULL":65,"OUTER":66,"INNER":67,"LEFT":68,"SEMI":69,"RIGHT":70,"ON":71,"UsingColList":72,"OptionalLimitClause":73,"LimitClause":74,"LIMIT":75,"UnsignedNumericLiteral":76,"VARIABLE_REFERENCE":77,"LimitClause_EDIT":78,"OptionalOrderByClause":79,"OrderByClause":80,"ORDER":81,"OrderByColumnList":82,"OrderByClause_EDIT":83,"OrderByColumnList_EDIT":84,"OrderByIdentifier":85,"OrderByIdentifier_EDIT":86,"OptionalAscOrDesc":87,"ASC":88,"DESC":89,"SELECT":90,"OptionalAllOrDistinct":91,"SelectList":92,"TableExpression":93,"SelectList_ERROR":94,"TableExpression_ERROR":95,"SelectList_EDIT":96,"TableExpression_EDIT":97,"SelectList_ERROR_EDIT":98,"ALL":99,"DISTINCT":100,"OptionalSelectConditions":101,"OptionalSelectConditions_EDIT":102,"SelectSpecification":103,"SelectSpecification_EDIT":104,"OptionalCorrelationName":105,"*":106,"OptionalCorrelationName_EDIT":107,"OptionalWhereClause":108,"WhereClause_EDIT":109,"WhereClause":110,"Unions":111,"Unions_EDIT":112,"UnionClause":113,"UnionClause_EDIT":114,"UNION":115,"NewStatement":116,"WHERE":117,"SearchCondition":118,"SearchCondition_EDIT":119,"UserDefinedFunction":120,"AggregateFunction":121,"OptionalOverClause":122,"AnalyticFunction":123,"OverClause":124,"CastFunction":125,"UserDefinedFunction_EDIT":126,"AggregateFunction_EDIT":127,"OptionalOverClause_EDIT":128,"AnalyticFunction_EDIT":129,"OverClause_EDIT":130,"CastFunction_EDIT":131,"OtherAggregateFunction":132,"CountFunction":133,"SumFunction":134,"OtherAggregateFunction_EDIT":135,"CountFunction_EDIT":136,"SumFunction_EDIT":137,"OtherAggregateFunction_Type":138,"UdfArgumentList":139,"UdfArgumentList_EDIT":140,"AVG":141,"MAX":142,"MIN":143,"STDDEV_POP":144,"STDDEV_SAMP":145,"VAR_POP":146,"VAR_SAMP":147,"VARIANCE":148,"COUNT":149,"SUM":150,"ANALYTIC":151,"ArbitraryFunctionName":152,"ARRAY":153,"IF":154,"MAP":155,"TRUNCATE":156,"CAST":157,"PrimitiveType":158,"NonParenthesizedValueExpressionPrimary":159,"ColumnOrArbitraryFunctionRef":160,"ArbitraryFunctionRightPart":161,"UnsignedValueSpecification":162,"NULL":163,"NonParenthesizedValueExpressionPrimary_EDIT":164,"ArbitraryFunctionRightPart_EDIT":165,"UnsignedValueSpecification_EDIT":166,"ColumnOrArbitraryFunctionRef_EDIT":167,"ArbitraryFunction":168,"RegularIdentifier":169,"ArbitraryFunction_EDIT":170,"OVER":171,"WindowExpression":172,"WindowExpression_EDIT":173,"SqlStatements":174,"NonStartingToken":175,"SqlStatement":176,";":177,"SqlStatement_EDIT":178,"DataDefinition_EDIT":179,"DataManipulation_EDIT":180,"SetSpecification_EDIT":181,"ErrorList":182,"Errors":183,"SetSpecification":184,"SET":185,"SetOption":186,"=":187,"DatabaseDefinition_EDIT":188,"CREATE":189,"DatabaseOrSchema":190,"OptionalIfNotExists":191,"DatabaseDefinitionOptionals_EDIT":192,"SqlSyntax":193,"EOF":194,"SqlAutocomplete":195,"SqlStatements_EDIT":196,"DataDefinition":197,"DataManipulation":198,"NonReservedKeyword":199,"ROLE":200,"OPTION":201,"STRUCT":202,"REGULAR_IDENTIFIER":203,"!":204,"-":205,".":206,"<":207,">":208,"[":209,"]":210,"~":211,"AND":212,"ARITHMETIC_OPERATOR":213,"BACKTICK":214,"BETWEEN":215,"BIGINT":216,"BOOLEAN":217,"CASE":218,"CHAR":219,"COMPARISON_OPERATOR":220,"CURRENT":221,"DATABASE":222,"DECIMAL":223,"DOUBLE":224,"DOUBLE_QUOTE":225,"ELSE":226,"END":227,"EXISTS":228,"FALSE":229,"FLOAT":230,"FOLLOWING":231,"HDFS_START_QUOTE":232,"IN":233,"INT":234,"INTO":235,"IS":236,"LIKE":237,"NOT":238,"OR":239,"PARTITION":240,"PRECEDING":241,"PURGE":242,"RANGE":243,"REGEXP":244,"RLIKE":245,"ROW":246,"ROWS":247,"SCHEMA":248,"SINGLE_QUOTE":249,"SMALLINT":250,"STRING":251,"TABLE":252,"THEN":253,"TIMESTAMP":254,"TINYINT":255,"TRUE":256,"UNSIGNED_INTEGER":257,"UNSIGNED_INTEGER_E":258,"VALUES":259,"VARCHAR":260,"WHEN":261,"Commas":262,"PARTIAL_CURSOR":263,"FromOrIn":264,"SingleQuotedValue":265,"VALUE":266,"SingleQuotedValue_EDIT":267,"PARTIAL_VALUE":268,"DoubleQuotedValue":269,"DoubleQuotedValue_EDIT":270,"QuotedValue":271,"QuotedValue_EDIT":272,"OptionalFromDatabase":273,"DatabaseIdentifier":274,"OptionalFromDatabase_EDIT":275,"DatabaseIdentifier_EDIT":276,"OptionalCascade":277,"CASCADE":278,"OptionalIfExists":279,"OptionalIfExists_EDIT":280,"OptionalIfNotExists_EDIT":281,"OptionalInDatabase":282,"OptionalPartitionSpec":283,"PartitionSpec":284,"OptionalPartitionSpec_EDIT":285,"PartitionSpec_EDIT":286,"PartitionSpecList":287,"PartitionSpecList_EDIT":288,"RangePartitionSpec":289,"RangePartitionComparisonOperator":290,"RangePartitionSpec_EDIT":291,"ConfigurationName":292,"PartialBacktickedOrAnyCursor":293,"PartialBacktickedIdentifier":294,"PartialBacktickedOrCursor":295,"PartialBacktickedOrPartialCursor":296,"OptionalParenthesizedColumnList":297,"ParenthesizedColumnList":298,"OptionalParenthesizedColumnList_EDIT":299,"ParenthesizedColumnList_EDIT":300,"ColumnList":301,"ColumnList_EDIT":302,"ColumnIdentifier":303,"ParenthesizedSimpleValueList":304,"SimpleValueList":305,"SchemaQualifiedTableIdentifier":306,"SchemaQualifiedTableIdentifier_EDIT":307,"SchemaQualifiedIdentifier":308,"SchemaQualifiedIdentifier_EDIT":309,"PartitionExpression":310,"PartitionExpression_EDIT":311,"RegularOrBackTickedSchemaQualifiedName":312,"RegularOrBackTickedSchemaQualifiedName_EDIT":313,"LocalOrSchemaQualifiedName":314,"LocalOrSchemaQualifiedName_EDIT":315,"BasicIdentifierChain":316,"BasicIdentifierChain_EDIT":317,"DerivedColumnChain":318,"DerivedColumnChain_EDIT":319,"PartialBacktickedIdentifierOrPartialCursor":320,"OptionalTypeLength":321,"OptionalTypePrecision":322,"OptionalNot":323,"TableSubQuery":324,"ValueExpressionList":325,"BETWEEN_AND":326,"LikeRightPart":327,"CaseRightPart":328,"TableSubQuery_EDIT":329,"ValueExpressionInSecondPart_EDIT":330,"LikeRightPart_EDIT":331,"CaseRightPart_EDIT":332,"EndOrError":333,"ValueExpressionList_EDIT":334,"InValueList":335,"SignedInteger":336,"+":337,"UnsignedLiteral":338,"UnsignedLiteral_EDIT":339,"GeneralLiteral":340,"GeneralLiteral_EDIT":341,"ExactNumericLiteral":342,"ApproximateNumericLiteral":343,"TruthValue":344,"TablePrimaryOrJoinedTable":345,"TablePrimaryOrJoinedTable_EDIT":346,"JoinedTable":347,"JoinedTable_EDIT":348,"TableOrQueryName":349,"DerivedTable":350,"TableOrQueryName_EDIT":351,"DerivedTable_EDIT":352,"OptionalOnColumn":353,"OptionalOnColumn_EDIT":354,"PushQueryState":355,"PopQueryState":356,"SubQuery":357,"SubQuery_EDIT":358,"QueryExpression":359,"QueryExpression_EDIT":360,"QueryExpressionBody":361,"QueryExpressionBody_EDIT":362,"NonJoinQueryExpression":363,"NonJoinQueryExpression_EDIT":364,"NonJoinQueryTerm":365,"NonJoinQueryTerm_EDIT":366,"NonJoinQueryPrimary":367,"NonJoinQueryPrimary_EDIT":368,"SimpleTable":369,"SimpleTable_EDIT":370,"OptionalPartitionBy":371,"OptionalOrderByAndWindow":372,"PartitionBy_EDIT":373,"OptionalOrderByAndWindow_EDIT":374,"PartitionBy":375,"OptionalWindowSpec":376,"WindowSpec_EDIT":377,"WindowSpec":378,"RowsOrRange":379,"PopLexerState":380,"OptionalCurrentOrPreceding":381,"OptionalAndFollowing":382,"UNBOUNDED":383,"OptionalCurrentOrPreceding_EDIT":384,"OptionalAndFollowing_EDIT":385,"PushHdfsLexerState":386,"HdfsPath":387,"HDFS_PATH":388,"HDFS_END_QUOTE":389,"HdfsPath_EDIT":390,"IntegerOrUnbounded":391,"CaseWhenThenList":392,"CaseWhenThenList_EDIT":393,"CaseWhenThenListPartTwo":394,"CaseWhenThenListPartTwo_EDIT":395,"$accept":0,"$end":1}, +terminals_: {2:"error",7:"(",8:")",13:"WITH",17:",",20:"AS",22:"CURSOR",27:"FROM",35:"GROUP",36:"BY",50:"HAVING",63:"CROSS",64:"JOIN",65:"FULL",66:"OUTER",67:"INNER",68:"LEFT",69:"SEMI",70:"RIGHT",71:"ON",75:"LIMIT",77:"VARIABLE_REFERENCE",81:"ORDER",88:"ASC",89:"DESC",90:"SELECT",95:"TableExpression_ERROR",99:"ALL",100:"DISTINCT",106:"*",115:"UNION",117:"WHERE",141:"AVG",142:"MAX",143:"MIN",144:"STDDEV_POP",145:"STDDEV_SAMP",146:"VAR_POP",147:"VAR_SAMP",148:"VARIANCE",149:"COUNT",150:"SUM",151:"ANALYTIC",153:"ARRAY",154:"IF",155:"MAP",156:"TRUNCATE",157:"CAST",163:"NULL",171:"OVER",177:";",179:"DataDefinition_EDIT",180:"DataManipulation_EDIT",181:"SetSpecification_EDIT",183:"Errors",185:"SET",186:"SetOption",187:"=",189:"CREATE",192:"DatabaseDefinitionOptionals_EDIT",194:"EOF",197:"DataDefinition",198:"DataManipulation",200:"ROLE",201:"OPTION",202:"STRUCT",203:"REGULAR_IDENTIFIER",204:"!",205:"-",206:".",207:"<",208:">",209:"[",210:"]",211:"~",212:"AND",213:"ARITHMETIC_OPERATOR",214:"BACKTICK",215:"BETWEEN",216:"BIGINT",217:"BOOLEAN",218:"CASE",219:"CHAR",220:"COMPARISON_OPERATOR",221:"CURRENT",222:"DATABASE",223:"DECIMAL",224:"DOUBLE",225:"DOUBLE_QUOTE",226:"ELSE",227:"END",228:"EXISTS",229:"FALSE",230:"FLOAT",231:"FOLLOWING",232:"HDFS_START_QUOTE",233:"IN",234:"INT",235:"INTO",236:"IS",237:"LIKE",238:"NOT",239:"OR",240:"PARTITION",241:"PRECEDING",242:"PURGE",243:"RANGE",244:"REGEXP",245:"RLIKE",246:"ROW",247:"ROWS",248:"SCHEMA",249:"SINGLE_QUOTE",250:"SMALLINT",251:"STRING",252:"TABLE",253:"THEN",254:"TIMESTAMP",255:"TINYINT",256:"TRUE",257:"UNSIGNED_INTEGER",258:"UNSIGNED_INTEGER_E",259:"VALUES",260:"VARCHAR",261:"WHEN",263:"PARTIAL_CURSOR",266:"VALUE",268:"PARTIAL_VALUE",278:"CASCADE",326:"BETWEEN_AND",337:"+",383:"UNBOUNDED",388:"HDFS_PATH",389:"HDFS_END_QUOTE"}, +productions_: [0,[3,3],[3,5],[3,2],[9,4],[9,3],[9,3],[9,1],[9,4],[9,3],[9,2],[9,2],[4,2],[12,2],[14,1],[14,3],[15,1],[15,3],[15,3],[15,5],[16,5],[18,2],[18,5],[18,5],[26,2],[29,2],[29,2],[28,1],[28,3],[30,1],[30,3],[30,3],[30,5],[30,3],[33,0],[33,1],[34,3],[38,3],[38,3],[38,2],[40,0],[40,1],[40,3],[40,3],[42,1],[42,3],[42,3],[42,5],[42,3],[43,1],[43,1],[37,1],[37,3],[39,1],[39,2],[39,3],[39,3],[39,3],[39,4],[39,5],[47,1],[47,2],[47,1],[48,0],[48,1],[49,2],[51,2],[51,2],[52,0],[52,1],[52,1],[53,3],[53,4],[54,1],[54,2],[58,3],[58,1],[58,3],[58,3],[58,3],[62,1],[62,2],[62,2],[62,3],[55,2],[55,2],[55,3],[55,2],[55,1],[55,3],[55,2],[55,3],[55,3],[55,2],[55,3],[55,2],[55,3],[55,3],[55,2],[59,2],[59,3],[59,3],[59,2],[59,3],[59,3],[59,3],[59,3],[59,2],[59,3],[59,3],[59,3],[59,3],[59,2],[59,3],[59,3],[59,3],[57,0],[57,2],[72,1],[72,3],[61,2],[61,2],[73,0],[73,1],[74,2],[74,4],[74,2],[74,4],[78,2],[79,0],[79,1],[80,3],[83,3],[83,2],[82,1],[82,3],[84,1],[84,2],[84,3],[84,4],[84,5],[85,2],[86,2],[86,2],[87,0],[87,1],[87,1],[5,3],[5,4],[5,4],[5,4],[10,3],[10,3],[10,4],[10,4],[10,4],[10,5],[10,6],[10,4],[10,4],[10,4],[91,0],[91,1],[91,1],[93,2],[97,2],[97,4],[97,3],[92,1],[92,3],[96,1],[96,2],[96,3],[96,3],[96,3],[96,4],[96,3],[96,3],[96,4],[96,4],[96,4],[96,5],[96,5],[103,2],[103,1],[104,2],[104,3],[104,2],[101,5],[102,5],[102,5],[102,5],[102,5],[102,5],[102,6],[102,6],[102,6],[102,6],[102,6],[102,7],[102,7],[102,7],[102,7],[102,6],[102,6],[102,6],[102,6],[102,6],[102,6],[102,6],[102,6],[102,6],[102,6],[6,0],[6,1],[11,1],[111,1],[111,2],[112,1],[112,2],[112,2],[112,3],[113,4],[114,3],[114,4],[114,4],[108,0],[108,1],[110,2],[109,2],[109,2],[118,1],[119,1],[120,2],[120,2],[120,1],[126,1],[126,2],[126,1],[126,2],[126,2],[126,2],[126,1],[121,1],[121,1],[121,1],[127,1],[127,1],[127,1],[132,4],[132,5],[135,5],[135,6],[135,5],[138,1],[138,1],[138,1],[138,1],[138,1],[138,1],[138,1],[138,1],[133,4],[133,3],[133,5],[136,5],[136,6],[136,5],[134,5],[134,3],[137,5],[137,6],[137,5],[123,3],[123,4],[129,4],[129,5],[129,4],[152,1],[152,1],[152,1],[152,1],[125,6],[125,3],[131,6],[131,5],[131,4],[131,6],[131,5],[131,4],[131,6],[131,5],[131,6],[131,5],[159,2],[159,2],[159,1],[159,1],[159,1],[159,1],[164,2],[164,2],[164,1],[164,1],[164,1],[168,2],[168,2],[170,2],[170,2],[161,2],[161,3],[165,3],[165,4],[165,3],[139,1],[139,3],[140,1],[140,3],[140,3],[140,5],[140,3],[140,5],[140,4],[140,3],[140,2],[140,2],[140,4],[122,0],[122,1],[128,1],[124,2],[124,2],[130,2],[174,1],[174,2],[174,0],[174,1],[174,4],[178,2],[178,1],[178,2],[178,1],[178,1],[178,1],[178,1],[94,1],[94,3],[94,5],[94,3],[94,5],[98,3],[98,5],[98,7],[98,3],[98,5],[98,7],[184,4],[182,1],[182,3],[188,6],[193,3],[195,3],[195,3],[116,0],[196,1],[196,4],[196,4],[196,7],[176,1],[176,1],[176,1],[199,1],[199,1],[199,1],[169,1],[169,1],[169,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[175,1],[262,1],[262,2],[23,1],[23,1],[264,1],[264,1],[190,1],[190,1],[265,3],[265,2],[267,2],[269,3],[269,2],[270,2],[271,1],[271,1],[272,1],[272,1],[273,0],[273,2],[275,2],[277,0],[277,1],[279,0],[279,2],[280,2],[191,0],[191,3],[281,2],[281,3],[282,0],[282,2],[282,2],[283,0],[283,1],[285,1],[284,4],[286,4],[289,5],[291,2],[291,3],[291,4],[291,5],[291,5],[291,5],[290,1],[290,1],[290,1],[290,1],[292,1],[292,1],[293,1],[293,1],[295,1],[295,1],[296,1],[296,1],[294,2],[24,1],[24,1],[297,0],[297,1],[299,1],[298,3],[300,3],[300,3],[301,1],[301,3],[302,3],[302,5],[304,3],[305,1],[305,3],[306,1],[306,3],[307,1],[307,3],[307,3],[308,1],[308,3],[309,1],[309,3],[309,3],[274,1],[276,1],[287,1],[287,3],[288,1],[288,3],[288,3],[288,5],[310,3],[311,3],[311,3],[311,3],[311,1],[19,1],[19,3],[19,2],[312,1],[312,3],[313,1],[313,3],[314,1],[314,2],[315,1],[315,2],[41,1],[41,3],[44,1],[316,1],[316,3],[317,3],[317,5],[318,1],[318,3],[319,1],[319,3],[319,5],[319,3],[303,1],[320,1],[320,1],[158,1],[158,1],[158,2],[158,2],[158,1],[158,1],[158,1],[158,1],[158,1],[158,1],[158,1],[158,2],[321,0],[321,3],[322,0],[322,3],[322,5],[45,1],[45,2],[45,2],[45,2],[45,2],[45,4],[45,4],[45,4],[45,6],[45,2],[45,3],[45,3],[45,3],[45,3],[45,3],[45,6],[45,6],[45,5],[45,5],[45,6],[45,5],[45,3],[45,3],[45,3],[45,3],[45,3],[45,2],[45,3],[45,2],[45,3],[46,1],[46,3],[46,2],[46,2],[46,2],[46,2],[46,2],[46,2],[46,2],[46,2],[46,3],[46,4],[46,5],[46,4],[46,4],[46,4],[46,6],[46,6],[46,2],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,4],[46,3],[46,6],[46,6],[46,5],[46,5],[46,6],[46,6],[46,6],[46,6],[46,5],[46,4],[46,5],[46,5],[46,5],[46,5],[46,4],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,2],[46,3],[46,2],[46,3],[46,2],[46,3],[46,2],[46,3],[46,3],[46,4],[46,3],[46,3],[46,3],[325,1],[325,3],[334,1],[334,3],[334,3],[334,5],[334,3],[334,5],[334,4],[334,3],[334,2],[334,2],[334,4],[335,1],[335,3],[160,1],[160,3],[167,1],[336,1],[336,2],[336,2],[162,1],[166,1],[338,1],[338,1],[339,1],[76,1],[76,1],[342,1],[342,2],[342,3],[342,2],[343,2],[343,3],[343,4],[340,1],[340,1],[340,1],[341,1],[341,1],[344,1],[344,1],[323,0],[323,1],[31,1],[32,1],[345,1],[345,1],[346,1],[346,1],[347,2],[348,2],[348,2],[56,2],[56,2],[60,2],[60,2],[60,2],[349,1],[351,1],[350,1],[352,1],[353,0],[353,2],[354,2],[354,2],[355,0],[356,0],[324,3],[324,4],[329,3],[329,3],[21,2],[25,3],[357,1],[358,1],[359,1],[360,1],[361,1],[362,1],[363,1],[364,1],[365,1],[366,1],[367,1],[368,1],[369,1],[370,1],[105,0],[105,1],[105,1],[105,2],[105,2],[107,1],[107,1],[107,2],[107,2],[107,2],[172,4],[173,4],[173,4],[173,5],[173,7],[371,0],[371,1],[375,3],[373,2],[373,3],[373,3],[372,0],[372,2],[374,1],[374,3],[374,2],[376,0],[376,1],[378,5],[378,5],[377,2],[377,6],[377,5],[377,5],[377,5],[377,4],[380,0],[386,0],[387,3],[390,5],[390,4],[390,3],[390,3],[390,2],[379,1],[379,1],[381,0],[381,2],[381,2],[384,2],[384,2],[382,0],[382,3],[382,3],[385,2],[385,3],[385,3],[391,1],[391,1],[330,3],[330,3],[330,3],[327,2],[327,2],[327,2],[331,2],[331,2],[331,2],[331,2],[331,2],[331,2],[328,2],[328,4],[332,2],[332,4],[332,4],[332,3],[332,4],[332,3],[332,4],[332,4],[332,3],[332,4],[332,3],[333,1],[333,1],[392,1],[392,2],[393,1],[393,2],[393,3],[393,3],[393,2],[394,4],[395,2],[395,3],[395,4],[395,4],[395,3],[395,3],[395,4],[395,2],[395,3],[395,2],[395,3],[395,3],[395,4],[395,3],[395,4],[395,4],[395,5],[395,4],[395,3]], +performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) { +/* this == yyval */ + +var $0 = $$.length - 1; +switch (yystate) { +case 2: case 182: +this.$ = $$[$0-2]; +break; +case 3: case 180: case 310: case 313: case 493: case 496: case 582: case 635: case 810: +this.$ = $$[$0-1]; +break; +case 4: + + parser.addCommonTableExpressions($$[$0-3]); + +break; +case 5: case 6: case 17: + + parser.addCommonTableExpressions($$[$0-2]); + +break; +case 12: case 28: case 52: case 131: case 135: case 177: case 187: case 228: case 350: case 351: case 352: case 735: case 737: case 792: case 847: case 922: +this.$ = $$[$0]; +break; +case 14: +this.$ = [$$[$0]]; +break; +case 15: +this.$ = $$[$0-2].concat([$$[$0]]); +break; +case 19: + + parser.addCommonTableExpressions($$[$0-4]); + +break; +case 20: + + parser.addCteAliasLocation(_$[$0-4], $$[$0-4]); + $$[$0-1].alias = $$[$0-4]; + this.$ = $$[$0-1]; + +break; +case 21: + + parser.suggestKeywords(['AS']); + +break; +case 22: case 340: case 813: + + parser.suggestKeywords(['SELECT']); + +break; +case 24: + + this.$ = { tableReferenceList : $$[$0] } + +break; +case 25: case 33: + + parser.suggestTables(); + parser.suggestDatabases({ appendDot: true }); + +break; +case 36: + + this.$ = { valueExpression: $$[$0] }; + +break; +case 37: case 142: + + parser.suggestSelectListAliases(); + +break; +case 38: + + parser.valueExpressionSuggest(); + parser.suggestSelectListAliases(); + parser.suggestGroupBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 39: + + parser.suggestKeywords(['BY']); + parser.suggestGroupBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 49: case 550: case 553: case 554: case 579: case 580: case 601: case 604: + + parser.suggestColumns(); + +break; +case 54: case 55: case 61: case 62: case 578: case 806: case 849: + + parser.valueExpressionSuggest(); + +break; +case 66: + + parser.valueExpressionSuggest(); + parser.suggestAggregateFunctions(); + parser.suggestSelectListAliases(true); + +break; +case 67: + + parser.suggestAggregateFunctions(); + parser.suggestSelectListAliases(true); + +break; +case 71: + + if ($$[$0] && $$[$0].valueExpression) { + this.$ = $$[$0].valueExpression; + } else { + this.$ = {}; + } + this.$.joinType = $$[$0-2]; + if ($$[$0].noJoinCondition) { + this.$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() } + } + if ($$[$0].suggestKeywords) { + this.$.suggestKeywords = $$[$0].suggestKeywords; + } + if (parser.yy.latestTablePrimaries.length > 0) { + parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true; + } + +break; +case 72: + + if ($$[$0] && $$[$0].valueExpression) { + this.$ = $$[$0].valueExpression; + } else { + this.$ = {}; + } + this.$.joinType = $$[$0-3]; + if ($$[$0].noJoinCondition) { + this.$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() } + } + if ($$[$0].suggestKeywords) { + this.$.suggestKeywords = $$[$0].suggestKeywords; + } + if (parser.yy.latestTablePrimaries.length > 0) { + parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true; + } + +break; +case 73: +this.$ = { joinType: $$[$0] }; +break; +case 74: +this.$ = { joinType: $$[$0-1] }; +break; +case 75: + + if ($$[$0-2].suggestKeywords) { + parser.suggestKeywords($$[$0-2].suggestKeywords); + } + +break; +case 76: + + if ($$[$0].suggestKeywords) { + parser.suggestKeywords($$[$0].suggestKeywords); + } + +break; +case 79: + + if (parser.yy.latestTablePrimaries.length > 0) { + var idx = parser.yy.latestTablePrimaries.length - 1; + var tables = []; + do { + var tablePrimary = parser.yy.latestTablePrimaries[idx]; + if (!tablePrimary.subQueryAlias) { + tables.unshift(tablePrimary.alias ? { identifierChain: tablePrimary.identifierChain, alias: tablePrimary.alias } : { identifierChain: tablePrimary.identifierChain }) + } + idx--; + } while (idx >= 0 && tablePrimary.join && !tablePrimary.subQueryAlias) + + if (tables.length > 0) { + parser.suggestJoins({ + prependJoin: false, + joinType: $$[$0-2], + tables: tables + }) + } + } + parser.suggestTables(); + parser.suggestDatabases({ + appendDot: true + }); + +break; +case 84: +this.$ = 'CROSS JOIN'; +break; +case 85: +this.$ = 'FULL JOIN'; +break; +case 86: +this.$ = 'FULL OUTER JOIN'; +break; +case 87: +this.$ = 'INNER JOIN'; +break; +case 88: +this.$ = 'JOIN'; +break; +case 89: +this.$ = 'LEFT INNER JOIN'; +break; +case 90: +this.$ = 'LEFT JOIN'; +break; +case 91: +this.$ = 'LEFT OUTER JOIN'; +break; +case 92: +this.$ = 'LEFT SEMI JOIN'; +break; +case 93: +this.$ = 'OUTER JOIN'; +break; +case 94: case 96: +this.$ = 'RIGHT OUTER JOIN'; +break; +case 95: +this.$ = 'RIGHT JOIN'; +break; +case 97: +this.$ = 'RIGHT SEMI JOIN'; +break; +case 98: +this.$ = 'SEMI JOIN'; +break; +case 99: case 101: case 102: case 104: case 105: case 106: case 107: case 109: case 110: case 111: case 112: +this.$ = { suggestKeywords: ['JOIN'] }; +break; +case 100: case 103: case 108: +this.$ = { suggestKeywords: ['OUTER'] }; +break; +case 113: case 114: case 115: + + parser.suggestKeywords(['JOIN', 'OUTER JOIN']); + +break; +case 116: +this.$ = { noJoinCondition: true, suggestKeywords: ['ON'] }; +break; +case 117: +this.$ = { valueExpression: $$[$0] }; +break; +case 121: + + parser.valueExpressionSuggest(); + parser.suggestJoinConditions({ prependOn: false }); + +break; +case 128: + + parser.suggestKeywords([{ value: '10', weight: 10000 }, { value: '100', weight: 10000 }, { value: '1000', weight: 10000 }, { value: '5000', weight: 10000 }, { value: '10000', weight: 10000 }]) + +break; +case 132: + + if ($$[$0].emptyOrderBy) { + parser.suggestOrderBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + +break; +case 133: + + parser.suggestKeywords(['BY']); + parser.suggestOrderBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 137: + + this.$ = { emptyOrderBy: false } + parser.valueExpressionSuggest(); + parser.suggestAnalyticFunctions(); + parser.suggestSelectListAliases(); + +break; +case 138: case 139: case 140: +this.$ = { emptyOrderBy: false }; +break; +case 141: +this.$ = parser.mergeSuggestKeywords($$[$0]); +break; +case 143: + + this.$ = { emptyOrderBy: true } + parser.valueExpressionSuggest(); + parser.suggestAnalyticFunctions(); + parser.suggestSelectListAliases(); + +break; +case 144: +this.$ = { suggestKeywords: ['ASC', 'DESC'] };; +break; +case 147: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2]), _$[$0]); + this.$ = { selectList: $$[$0] }; + +break; +case 148: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + this.$ = { selectList: $$[$0-1], tableExpression: $$[$0] } + +break; +case 151: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2]), _$[$0]); + if ($$[$0].cursorAtStart) { + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-1]) { + keywords = keywords.concat(parser.SELECT_FIRST_OPTIONAL_KEYWORDS); + } + parser.suggestKeywords(keywords); + } else { + parser.checkForSelectListKeywords($$[$0]); + } + if ($$[$0].suggestFunctions) { + parser.suggestFunctions(); + } + if ($$[$0].suggestColumns) { + parser.suggestColumns({ identifierChain: [], source: 'select' }); + } + if ($$[$0].suggestTables) { + parser.suggestTables({ prependQuestionMark: true, prependFrom: true }); + } + if ($$[$0].suggestDatabases) { + parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true }); + } + if ($$[$0].suggestAggregateFunctions && (!$$[$0-1] || $$[$0-1] === 'ALL')) { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + +break; +case 152: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2]), _$[$0], true); + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-1] || $$[$0-1] === 'ALL') { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + if (!$$[$0-1]) { + keywords = keywords.concat(parser.SELECT_FIRST_OPTIONAL_KEYWORDS); + } + parser.suggestKeywords(keywords); + parser.suggestFunctions(); + parser.suggestColumns({ identifierChain: [], source: 'select' }); + parser.suggestTables({ prependQuestionMark: true, prependFrom: true }); + parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true }); + +break; +case 153: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + +break; +case 154: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + parser.selectListNoTableSuggest($$[$0-1], $$[$0-2]); + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'select'; + } + +break; +case 155: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1], true); + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-2] || $$[$0-2] === 'ALL') { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + if (!$$[$0-2]) { + keywords = keywords.concat(parser.SELECT_FIRST_OPTIONAL_KEYWORDS); + } + parser.suggestKeywords(keywords); + parser.suggestFunctions(); + parser.suggestColumns({ identifierChain: [], source: 'select' }); + parser.suggestTables({ prependQuestionMark: true, prependFrom: true }); + parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true }); + +break; +case 156: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-2]); + parser.checkForSelectListKeywords($$[$0-2]); + +break; +case 157: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5]), _$[$0-3]); + parser.checkForSelectListKeywords($$[$0-3]); + +break; +case 158: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + parser.checkForSelectListKeywords($$[$0-1]); + var keywords = ['FROM']; + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + parser.suggestTables({ prependFrom: true }); + parser.suggestDatabases({ prependFrom: true, appendDot: true }); + +break; +case 159: + + parser.selectListNoTableSuggest($$[$0-1], $$[$0-2]); + +break; +case 164: case 165: + + parser.addClauseLocation('whereClause', _$[$0-1], $$[$0].whereClauseLocation); + parser.addClauseLocation('limitClause', $$[$0].limitClausePreceding || _$[$0-1], $$[$0].limitClauseLocation); + +break; +case 166: + + var keywords = []; + + parser.addClauseLocation('whereClause', _$[$0-3], $$[$0-1].whereClauseLocation); + parser.addClauseLocation('limitClause', $$[$0-2].limitClausePreceding || _$[$0-3], $$[$0-2].limitClauseLocation); + + if ($$[$0-3]) { + if (typeof $$[$0-3].tableReferenceList.hasJoinCondition !== 'undefined' && !$$[$0-3].tableReferenceList.hasJoinCondition) { + keywords.push({ value: 'ON', weight: 3 }); + } + if ($$[$0-3].suggestKeywords) { + keywords = parser.createWeightedKeywords($$[$0-3].suggestKeywords, 3); + } + if ($$[$0-3].tableReferenceList.suggestJoinConditions) { + parser.suggestJoinConditions($$[$0-3].tableReferenceList.suggestJoinConditions); + } + if ($$[$0-3].tableReferenceList.suggestJoins) { + parser.suggestJoins($$[$0-3].tableReferenceList.suggestJoins); + } + if ($$[$0-3].tableReferenceList.suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-3].tableReferenceList.suggestKeywords, 3)); + } + + // Lower the weights for 'TABLESAMPLE' + keywords.forEach(function (keyword) { + if (keyword.value === 'TABLESAMPLE') { + keyword.weight = 1.1; + } + }); + + if ($$[$0-3].tableReferenceList.types) { + var veKeywords = parser.getValueExpressionKeywords($$[$0-3].tableReferenceList); + keywords = keywords.concat(veKeywords.suggestKeywords); + if (veKeywords.suggestColRefKeywords) { + parser.suggestColRefKeywords(veKeywords.suggestColRefKeywords); + parser.addColRefIfExists($$[$0-3].tableReferenceList); + } + } + } + + if ($$[$0-1].empty && $$[$0] && $$[$0].joinType.toUpperCase() === 'JOIN') { + keywords = keywords.concat(['FULL', 'FULL OUTER', 'INNER', 'LEFT', 'LEFT OUTER', 'RIGHT', 'RIGHT OUTER']); + parser.suggestKeywords(keywords); + return; + } + + if ($$[$0-1].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2)); + } + + if ($$[$0-1].suggestFilters) { + parser.suggestFilters($$[$0-1].suggestFilters); + } + if ($$[$0-1].suggestGroupBys) { + parser.suggestGroupBys($$[$0-1].suggestGroupBys); + } + if ($$[$0-1].suggestOrderBys) { + parser.suggestOrderBys($$[$0-1].suggestOrderBys); + } + + if ($$[$0-1].empty) { + keywords.push({ value: 'UNION', weight: 2.11 }); + } + + keywords = keywords.concat([ + { value: 'FULL JOIN', weight: 1 }, + { value: 'FULL OUTER JOIN', weight: 1 }, + { value: 'INNER JOIN', weight: 1 }, + { value: 'JOIN', weight: 1 }, + { value: 'LEFT JOIN', weight: 1 }, + { value: 'LEFT OUTER JOIN', weight: 1 }, + { value: 'RIGHT JOIN', weight: 1 }, + { value: 'RIGHT OUTER JOIN', weight: 1 } + ]); + parser.suggestKeywords(keywords); + +break; +case 167: + + // A couple of things are going on here: + // - If there are no SelectConditions (WHERE, GROUP BY, etc.) we should suggest complete join options + // - If there's an OptionalJoin at the end, i.e. 'SELECT * FROM foo | JOIN ...' we should suggest + // different join types + // - The FromClause could end with a valueExpression, in which case we should suggest keywords like '=' + // or 'AND' based on type + + if (!$$[$0-1]) { + parser.addClauseLocation('whereClause', _$[$0-2]); + parser.addClauseLocation('limitClause', _$[$0-2]); + return; + } + parser.addClauseLocation('whereClause', _$[$0-2], $$[$0-1].whereClauseLocation); + parser.addClauseLocation('limitClause', $$[$0-1].limitClausePreceding || _$[$0-2], $$[$0-1].limitClauseLocation); + var keywords = []; + + if ($$[$0-1].suggestColRefKeywords) { + parser.suggestColRefKeywords($$[$0-1].suggestColRefKeywords); + parser.addColRefIfExists($$[$0-1]); + } + + if ($$[$0-1].suggestKeywords && $$[$0-1].suggestKeywords.length) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2)); + } + + if ($$[$0-1].cursorAtEnd) { + keywords.push({ value: 'UNION', weight: 2.11 }); + } + parser.suggestKeywords(keywords); + +break; +case 168: +this.$ = [ $$[$0] ]; +break; +case 169: + + $$[$0-2].push($$[$0]); + +break; +case 171: case 172: case 355: + + this.$ = { cursorAtStart : true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true }; + +break; +case 174: + + parser.checkForSelectListKeywords($$[$0-2]); + +break; +case 175: + + parser.checkForSelectListKeywords($$[$0-3]); + +break; +case 176: + + this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestTables: true, suggestDatabases: true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true }; + +break; +case 178: case 179: case 181: + + this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true, }; + +break; +case 183: + + if ($$[$0]) { + parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0-1]); + this.$ = { valueExpression: $$[$0-1], alias: $$[$0].alias }; + if (!parser.yy.selectListAliases) { + parser.yy.selectListAliases = []; + } + parser.yy.selectListAliases.push($$[$0-1].function && $$[$0-1].types && $$[$0-1].types.length && $$[$0-1].types[0] === 'UDFREF' ? { name: $$[$0].alias, udfRef: $$[$0-1].function, types: $$[$0-1].types } : { name: $$[$0].alias, types: $$[$0-1].types || ['T'] }); + } else { + this.$ = { valueExpression: $$[$0-1] } + } + +break; +case 184: + + parser.addAsteriskLocation(_$[$0], [{ asterisk: true }]); + this.$ = { asterisk: true } + +break; +case 185: + + if ($$[$0]) { + parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0-1]); + } + +break; +case 186: + + parser.suggestFunctions(); + parser.suggestColumns(); + parser.addColumnAliasLocation(_$[$0], $$[$0], _$[$0-2]); + this.$ = { suggestAggregateFunctions: true }; + +break; +case 188: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], + [{ value: 'WHERE', weight: 7 }, { value: 'GROUP BY', weight: 6 }, { value: 'HAVING', weight: 5 }, { value: 'ORDER BY', weight: 4 }, { value: 'LIMIT', weight: 3 }], + [true, true, true, true, true]); + + if (keywords.length > 0) { + this.$ = { suggestKeywords: keywords, empty: !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0] }; + } else { + this.$ = {}; + } + + this.$.whereClauseLocation = $$[$0-4] ? _$[$0-4] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + + if (!$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) { + this.$.suggestFilters = { prefix: 'WHERE', tablePrimaries: parser.yy.latestTablePrimaries.concat() }; + } + if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) { + this.$.suggestGroupBys = { prefix: 'GROUP BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }; + } + if (!$$[$0-1] && !$$[$0]) { + this.$.suggestOrderBys = { prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }; + } + +break; +case 189: + + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'where'; + } + +break; +case 190: + + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'group by'; + } + +break; +case 192: + + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'order by'; + } + +break; +case 194: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], + [{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], + [true, true, true, true]); + if ($$[$0-5].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-5].suggestKeywords, 1)); + } + this.$ = parser.getValueExpressionKeywords($$[$0-5], keywords); + this.$.cursorAtEnd = !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]; + if ($$[$0-5].columnReference) { + this.$.columnReference = $$[$0-5].columnReference; + } + if (!$$[$0-3]) { + parser.suggestGroupBys({ prefix: 'GROUP BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1]) { + parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-5], _$[$0-5]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 195: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-2], $$[$0-1], $$[$0]], + [{ value: 'HAVING', weight: 7 }, { value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], + [true, true, true]); + if ($$[$0-4].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-4].suggestKeywords, 8)); + } + if ($$[$0-4].valueExpression) { + this.$ = parser.getValueExpressionKeywords($$[$0-4].valueExpression, keywords); + if ($$[$0-4].valueExpression.columnReference) { + this.$.columnReference = $$[$0-4].valueExpression.columnReference; + } + } else { + this.$ = { suggestKeywords: keywords }; + } + this.$.cursorAtEnd = !$$[$0-2] && !$$[$0-1] && !$$[$0]; + if (!$$[$0-2] && !$$[$0-1]) { + parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-4], _$[$0-4]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 196: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-1], $$[$0]], + [{ value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], + [true, true]); + this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0-1] && !$$[$0] }; + if (!$$[$0-1]) { + parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-3], _$[$0-3]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 197: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0]], + [{ value: 'LIMIT', weight: 3 }], + [true]); + if ($$[$0-2].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-2].suggestKeywords, 4)); + } + this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0] }; + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 198: + + this.$ = { suggestKeywords: [], cursorAtEnd: true }; + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5]); + this.$.limitClauseLocation = _$[$0-1]; + +break; +case 199: + + this.$ = { + suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], [{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], [true, true, true, true]), + cursorAtEnd: !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0] + }; + +break; +case 200: + + this.$ = { + suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0-1], $$[$0]], [{ value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], [true, true]), + cursorAtEnd: !$$[$0-1] && !$$[$0] + } + +break; +case 201: + + this.$ = { + suggestKeywords: parser.getKeywordsForOptionalsLR([$$[$0]], [{ value: 'LIMIT', weight: 3 }], [true]), + cursorAtEnd: !$$[$0] + } + +break; +case 223: + + parser.suggestKeywords(['ALL', 'DISTINCT', 'SELECT']); + +break; +case 224: + + parser.suggestKeywords(['ALL', 'DISTINCT']); + +break; +case 229: + + if ($$[$0].suggestFilters) { + parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + +break; +case 230: + + parser.suggestFunctions(); + parser.suggestColumns(); + parser.suggestKeywords(['EXISTS', 'NOT EXISTS']); + parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 233: + + if (!$$[$0]) { + $$[$0-1].suggestKeywords = ['OVER']; + } + +break; +case 240: + + parser.suggestKeywords(['OVER']); + +break; +case 249: + + this.$ = { function: $$[$0-3], types: ['UDFREF'] }; + +break; +case 250: case 268: + + parser.addFunctionArgumentLocations($$[$0-4], $$[$0-1].expressions); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 251: + + parser.valueExpressionSuggest(); + var keywords = parser.getSelectListKeywords(true); + if (!$$[$0-2]) { + if ($$[$0-4].toLowerCase() === 'group_concat') { + keywords.push('ALL'); + } else { + keywords.push('DISTINCT'); + } + } + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + parser.applyArgumentTypesToSuggestions($$[$0-4], 1); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 252: case 266: + + parser.suggestValueExpressionKeywords($$[$0-2].expressions[$$[$0-2].expressions.length - 1].expression); + this.$ = { function: $$[$0-5], types: ['UDFREF'] }; + +break; +case 253: + + if ($$[$0-1].cursorAtStart) { + var keywords = parser.getSelectListKeywords(true); + if (!$$[$0-2]) { + if ($$[$0-4].toLowerCase() === 'group_concat') { + keywords.push('ALL'); + } else { + keywords.push('DISTINCT'); + } + } + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + } + if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) { + parser.applyArgumentTypesToSuggestions($$[$0-4], $$[$0-1].activePosition); + } + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 262: + + parser.addFunctionArgumentLocations($$[$0-3], [{ + expression: { text: $$[$0-1] }, + location: _$[$0-1] + }]); + this.$ = { function: $$[$0-3], types: ['UDFREF'] } + +break; +case 263: case 269: + + this.$ = { function: $$[$0-2], types: ['UDFREF'] } + +break; +case 264: + + parser.addFunctionArgumentLocations($$[$0-4], $$[$0-1].expressions); + this.$ = { function: $$[$0-4], types: ['UDFREF'] } + +break; +case 265: + + parser.valueExpressionSuggest(); + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-2]) { + keywords.push('DISTINCT'); + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + } + parser.suggestKeywords(keywords); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 267: + + if ($$[$0-1].cursorAtStart) { + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-2]) { + keywords.push('DISTINCT'); + } + parser.suggestKeywords(keywords); + } + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 270: + + parser.valueExpressionSuggest(); + parser.applyArgumentTypesToSuggestions($$[$0-4], 1); + var keywords = parser.getSelectListKeywords(true); + if (!$$[$0-2]) { + keywords.push('DISTINCT'); + } + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 271: + + parser.suggestValueExpressionKeywords($$[$0-2]); + this.$ = { function: $$[$0-5], types: ['UDFREF'] }; + +break; +case 272: + + if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) { + parser.applyArgumentTypesToSuggestions($$[$0-4], 1); + } + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 273: + + this.$ = { function: $$[$0-2], types: ['UDFREF'] } + +break; +case 274: + + parser.addFunctionArgumentLocations($$[$0-3], $$[$0-1].expressions); + this.$ = { + function: $$[$0-3], + expression: $$[$0-1].expressions[$$[$0-1].expressions.length - 1].expression, + types: ['UDFREF'] + } + +break; +case 275: + + parser.valueExpressionSuggest(); + parser.applyArgumentTypesToSuggestions($$[$0-3], 1); + this.$ = { function: $$[$0-3], types: ['UDFREF'] }; + +break; +case 276: + + parser.addFunctionArgumentLocations($$[$0-4], $$[$0-2].expressions); + parser.suggestValueExpressionKeywords($$[$0-2].expressions[$$[$0-2].expressions.length - 1].expression); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 277: + + parser.addFunctionArgumentLocations($$[$0-3], $$[$0-1].expressions); + parser.applyArgumentTypesToSuggestions($$[$0-3], $$[$0-1].activePosition); + this.$ = { function: $$[$0-3], types: ['UDFREF'] }; + +break; +case 282: + + var expression = $$[$0-3]; + parser.extractExpressionText(expression, $$[$0-3], $$[$0-2], $$[$0-1]); + parser.addFunctionArgumentLocations($$[$0-5], [{ + expression: expression, + location: { + first_line: _$[$0-3].first_line, + last_line: _$[$0-1].last_line, + first_column: _$[$0-3].first_column, + last_column: _$[$0-1].last_column + } + }]); + this.$ = { types: [ $$[$0-1].toUpperCase() ] } + +break; +case 283: case 288: case 289: case 741: +this.$ = { types: [ 'T' ] }; +break; +case 284: + + parser.valueExpressionSuggest(); + this.$ = { types: [ $$[$0-1].toUpperCase() ] }; + +break; +case 285: case 286: + + parser.valueExpressionSuggest(); + this.$ = { types: [ 'T' ] }; + +break; +case 287: +this.$ = { types: [ $$[$0-1].toUpperCase() ] }; +break; +case 290: + + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'AS', weight: 2 }]); + this.$ = { types: [ $$[$0-1].toUpperCase() ] }; + +break; +case 291: + + parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'AS', weight: 2 }]); + this.$ = { types: [ 'T' ] }; + +break; +case 292: case 293: + + parser.suggestKeywords(parser.getTypeKeywords()); + this.$ = { types: [ 'T' ] }; + +break; +case 294: + + // We need to handle arbitrary UDFs here instead of inside UserDefinedFunction or there will be a conflict + // with columnReference for functions like: db.udf(foo) + var fn = $$[$0-1].chain[$$[$0-1].chain.length - 1].name.toLowerCase(); + parser.addFunctionArgumentLocations(fn, $$[$0].expressions, $$[$0-1].chain); + if ($$[$0-1].lastLoc && $$[$0-1].lastLoc.location) { + $$[$0-1].lastLoc.type = 'function'; + $$[$0-1].lastLoc.function = fn; + $$[$0-1].lastLoc.location = { + first_line: $$[$0-1].lastLoc.location.first_line, + last_line: $$[$0-1].lastLoc.location.last_line, + first_column: $$[$0-1].lastLoc.location.first_column, + last_column: $$[$0-1].lastLoc.location.last_column - 1 + } + if ($$[$0-1].lastLoc !== $$[$0-1].firstLoc) { + $$[$0-1].firstLoc.type = 'database'; + } else { + delete $$[$0-1].lastLoc.identifierChain; + } + } + if ($$[$0].expressions && $$[$0].expressions.length) { + this.$ = { function: fn, expression: $$[$0].expressions[$$[$0].expressions.length - 1].expression, types: ['UDFREF'] } + } else { + this.$ = { function: fn, types: ['UDFREF'] } + } + +break; +case 295: + + parser.addFunctionLocation(_$[$0-1], $$[$0-1]); + if ($$[$0].expressions && $$[$0].expressions.length) { + this.$ = { function: $$[$0-1], expression: $$[$0].expressions[$$[$0].expressions.length - 1].expression, types: ['UDFREF'] } + } else { + this.$ = { function: $$[$0-1], types: ['UDFREF'] } + } + +break; +case 298: +this.$ = { types: ['COLREF'], columnReference: $$[$0].chain }; +break; +case 299: +this.$ = { types: [ 'NULL' ], text: $$[$0] }; +break; +case 300: + + var fn = $$[$0-1].chain[$$[$0-1].chain.length - 1].name.toLowerCase(); + parser.addFunctionArgumentLocations(fn, $$[$0].expressions, $$[$0-1].chain); + $$[$0-1].lastLoc.type = 'function'; + $$[$0-1].lastLoc.function = fn; + $$[$0-1].lastLoc.location = { + first_line: $$[$0-1].lastLoc.location.first_line, + last_line: $$[$0-1].lastLoc.location.last_line, + first_column: $$[$0-1].lastLoc.location.first_column, + last_column: $$[$0-1].lastLoc.location.last_column - 1 + } + if ($$[$0-1].lastLoc !== $$[$0-1].firstLoc) { + $$[$0-1].firstLoc.type = 'database'; + } else { + delete $$[$0-1].lastLoc.identifierChain; + } + if ($$[$0].activePosition) { + parser.applyArgumentTypesToSuggestions(fn, $$[$0].activePosition); + } + this.$ = { function: fn, types: ['UDFREF'] }; + +break; +case 301: case 307: case 308: + + parser.addFunctionLocation(_$[$0-1], $$[$0-1]); + parser.addFunctionArgumentLocations($$[$0-1], $$[$0].expressions); + if ($$[$0].activePosition) { + parser.applyArgumentTypesToSuggestions($$[$0-1], $$[$0].activePosition); + } + this.$ = { function: $$[$0-1], types: ['UDFREF'] }; + +break; +case 304: + + if ($$[$0].suggestKeywords) { + this.$ = { types: ['COLREF'], columnReference: $$[$0], suggestKeywords: $$[$0].suggestKeywords }; + } else { + this.$ = { types: ['COLREF'], columnReference: $$[$0] }; + } + +break; +case 305: case 306: + + parser.addFunctionLocation(_$[$0-1], $$[$0-1]); + parser.addFunctionArgumentLocations($$[$0-1], $$[$0].expressions); + if ($$[$0].expressions && $$[$0].expressions.length) { + this.$ = { function: $$[$0-1], expression: $$[$0].expressions[$$[$0].expressions.length - 1].expression, types: ['UDFREF'] } + } else { + this.$ = { function: $$[$0-1], types: ['UDFREF'] } + } + +break; +case 311: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: 1, + expressions: [{ expression: { text: '' }, location: _$[$0-1] }] + } + +break; +case 312: + + parser.suggestValueExpressionKeywords($$[$0-2].expressions[$$[$0-2].expressions.length - 1].expression); + this.$ = $$[$0-3]; + +break; +case 314: case 316: + + this.$ = { + activePosition: 1, + expressions: [{ expression: $$[$0], location: _$[$0] }] + } + +break; +case 315: case 317: + + this.$ = { + activePosition: $$[$0-2].activePosition + 1, + expressions: $$[$0-2].expressions.concat([{ expression: $$[$0], location: _$[$0] }]) + } + +break; +case 318: + + this.$ = { + activePosition: 1, + expressions: [{ expression: $$[$0-2], location: _$[$0-2] }].concat($$[$0].expressions) + } + +break; +case 319: + + this.$ = { + activePosition: $$[$0-4].activePosition + 1, + expressions: $$[$0-4].expressions.concat([{ expression: $$[$0-2], location: _$[$0-2] }]).concat($$[$0].expressions) + } + +break; +case 320: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: $$[$0-2].activePosition + 1, + expressions: $$[$0-2].expressions.concat([{ expression: { text: '' }, location: _$[$0] }]) + } + +break; +case 321: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: $$[$0-4].activePosition + 1, + expressions: $$[$0-4].expressions.concat([{ expression: { text: '' }, location: _$[$0-2] }]).concat($$[$0].expressions) + } + +break; +case 322: + + parser.suggestValueExpressionKeywords($$[$0-3].expressions[$$[$0-3].expressions.length - 1].expression); + this.$ = { + activePosition: $$[$0-3].activePosition, + expressions: $$[$0-3].expressions.concat($$[$0].expressions) + } + +break; +case 323: + + parser.valueExpressionSuggest(); + this.$ = { + cursorAtStart : true, + activePosition: 1, + expressions: [{ expression: { text: '' }, location: _$[$0-2] }].concat($$[$0].expressions) + }; + +break; +case 324: + + parser.valueExpressionSuggest(); + this.$ = { + cursorAtStart : true, + activePosition: 1, + expressions: [{ expression: { text: '' }, location: _$[$0-1] }, { expression: { text: '' }, location: _$[$0] }] + }; + +break; +case 325: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: 2, + expressions: [{ expression: { text: '' }, location: _$[$0-1] }, { expression: { text: '' }, location: _$[$0] }] + }; + +break; +case 326: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: 2, + expressions: [{ expression: { text: '' }, location: _$[$0-3] }, { expression: { text: '' }, location: _$[$0-2] }].concat($$[$0].expressions) + }; + +break; +case 336: case 364: case 366: + + parser.addStatementLocation(_$[$0]); + +break; +case 338: case 339: + + parser.suggestDdlAndDmlKeywords(); + +break; +case 353: case 354: + + this.$ = { cursorAtStart : false, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true }; + +break; +case 361: case 362: + + return parser.yy.result; + +break; +case 363: + + parser.prepareNewStatement(); + +break; +case 365: case 367: + + parser.addStatementLocation(_$[$0-3]); + +break; +case 494: case 497: case 583: +this.$ = ''; +break; +case 509: case 512: + + parser.yy.correlatedSubQuery = false; + +break; +case 510: case 514: + + parser.suggestKeywords(['EXISTS']); + +break; +case 513: + + parser.suggestKeywords(['NOT EXISTS']); + +break; +case 524: case 526: case 527: case 529: + + parser.suggestKeywords(['<', '<=', '<>', '=', '>', '>=']); + +break; +case 525: case 528: + + parser.suggestKeywords(['VALUES']); + +break; +case 558: case 584: + + parser.addTableLocation(_$[$0], [ { name: $$[$0] } ]); + this.$ = { identifierChain: [ { name: $$[$0] } ] }; + +break; +case 559: case 585: + + parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]); + parser.addTableLocation(_$[$0], [ { name: $$[$0-2] }, { name: $$[$0] } ]); + this.$ = { identifierChain: [ { name: $$[$0-2] }, { name: $$[$0] } ] }; + +break; +case 560: + + parser.suggestTables(); + parser.suggestDatabases({ appendDot: true }); + +break; +case 561: case 566: + + parser.suggestDatabases(); + this.$ = { identifierChain: [{ name: $$[$0-2] }] }; + +break; +case 562: case 587: + + parser.suggestTablesOrColumns($$[$0-2]); + +break; +case 563: +this.$ = [{ name: $$[$0] }]; +break; +case 564: +this.$ = [{ name: $$[$0-2] }, { name: $$[$0-1] }]; +break; +case 565: + + parser.suggestDatabases({ appendDot: true }); + +break; +case 569: + + parser.suggestDatabases(); + +break; +case 586: + + parser.suggestTables(); + parser.suggestDatabases({ prependDot: true }); + +break; +case 589: +this.$ = { identifierChain: $$[$0-1].identifierChain, alias: $$[$0] }; +break; +case 592: + + parser.yy.locations[parser.yy.locations.length - 1].type = 'column'; + +break; +case 593: case 758: + + parser.addAsteriskLocation(_$[$0], $$[$0-2].concat({ asterisk: true })); + +break; +case 595: + + this.$ = [ $$[$0].identifier ]; + parser.yy.firstChainLocation = parser.addUnknownLocation($$[$0].location, [ $$[$0].identifier ]); + +break; +case 596: + + if (parser.yy.firstChainLocation) { + parser.yy.firstChainLocation.firstInChain = true; + delete parser.yy.firstChainLocation; + } + $$[$0-2].push($$[$0].identifier); + parser.addUnknownLocation($$[$0].location, $$[$0-2].concat()); + +break; +case 597: + + parser.suggestColumns({ + identifierChain: $$[$0-2] + }); + this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] }; + +break; +case 598: + + parser.suggestColumns({ + identifierChain: $$[$0-4] + }); + this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] }; + +break; +case 599: +this.$ = [ $$[$0].identifier ]; +break; +case 600: + + $$[$0-2].push($$[$0].identifier); + +break; +case 602: + + parser.suggestColumns({ identifierChain: $$[$0-2] }); + +break; +case 603: + + parser.suggestColumns({ identifierChain: $$[$0-4] }); + +break; +case 605: +this.$ = { identifier: { name: $$[$0] }, location: _$[$0] }; +break; +case 626: case 627: + + // verifyType($$[$0], 'BOOLEAN'); + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 628: case 653: + + this.$ = $$[$0]; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 629: + + // verifyType($$[$0], 'NUMBER'); + this.$ = $$[$0]; + $$[$0].types = ['NUMBER']; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 630: case 631: case 632: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 633: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 634: + + this.$ = { types: [ 'BOOLEAN' ] }; + // clear correlated flag after completed sub-query (set by lexer) + parser.yy.correlatedSubQuery = false; + +break; +case 636: case 637: case 638: case 639: + + parser.addColRefToVariableIfExists($$[$0-2], $$[$0]); + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 640: case 641: case 642: case 643: case 673: case 731: case 732: +this.$ = { types: [ 'BOOLEAN' ] }; +break; +case 644: + + this.$ = { types: [ 'BOOLEAN' ] } + parser.extractExpressionText(this.$, $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 645: + + this.$ = { types: [ 'BOOLEAN' ] } + parser.extractExpressionText(this.$, $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 646: case 647: + + // verifyType($$[$0-2], 'BOOLEAN'); + // verifyType($$[$0], 'BOOLEAN'); + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 648: case 649: case 650: + + // verifyType($$[$0-2], 'NUMBER'); + // verifyType($$[$0], 'NUMBER'); + this.$ = { types: [ 'NUMBER' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 651: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 652: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 654: + + this.$ = $$[$0]; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 656: + + parser.suggestKeywords(['BETWEEN', 'EXISTS', 'IN', 'LIKE', 'REGEXP', 'RLIKE']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 657: case 659: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }; +break; +case 658: + + parser.suggestFunctions(); + parser.suggestColumns(); + parser.suggestKeywords(['EXISTS']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 660: + + parser.suggestFunctions({ types: [ 'BOOLEAN' ] }); + parser.suggestColumns({ types: [ 'BOOLEAN' ] }); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 661: +this.$ = { types: [ 'T' ], suggestFilters: $$[$0].suggestFilters }; +break; +case 662: + + parser.suggestFunctions(); + parser.suggestColumns(); + this.$ = { types: [ 'T' ] }; + +break; +case 663: + + if (!$$[$0].typeSet) { + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + } + this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 664: + + parser.suggestFunctions({ types: [ 'NUMBER' ] }); + parser.suggestColumns({ types: [ 'NUMBER' ] }); + this.$ = { types: [ 'NUMBER' ] }; + +break; +case 665: + + parser.suggestKeywords(['FALSE', 'NOT NULL', 'NOT TRUE', 'NOT FALSE', 'NULL', 'TRUE']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 666: + + parser.suggestKeywords(['FALSE', 'NULL', 'TRUE']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 667: + + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 668: case 669: case 670: + + parser.suggestKeywords(['NOT']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 671: + + parser.valueExpressionSuggest($$[$0-5], $$[$0-3] ? 'IS NOT DISTINCT FROM' : 'IS DISTINCT FROM'); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 672: + + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters } + +break; +case 674: + + this.$ = $$[$0-1]; + +break; +case 675: + + parser.valueExpressionSuggest(); + this.$ = { types: ['T'], typeSet: true }; + +break; +case 676: + + parser.valueExpressionSuggest($$[$0], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 677: case 678: case 679: + + parser.valueExpressionSuggest($$[$0], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 680: case 681: case 682: case 683: + + if (!$$[$0-2].typeSet) { + parser.applyTypeToSuggestions($$[$0]); + parser.addColRefIfExists($$[$0]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters } + +break; +case 684: case 686: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 685: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ] , typeSet: true, endsWithLessThanOrEqual: true }; + +break; +case 687: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true, endsWithLessThanOrEqual: $$[$0-1] === '<=' }; + +break; +case 688: case 689: case 690: case 691: + + if (!$$[$0].typeSet) { + parser.applyTypeToSuggestions($$[$0-2]); + parser.addColRefIfExists($$[$0-2]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters } + +break; +case 692: + + if ($$[$0].inValueEdit) { + parser.valueExpressionSuggest($$[$0-3], $$[$0-2] + ' ' + $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-3]); + } + if ($$[$0].cursorAtStart) { + parser.suggestKeywords(['SELECT']); + } + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 693: + + if ($$[$0].inValueEdit) { + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + } + if ($$[$0].cursorAtStart) { + parser.suggestKeywords(['SELECT']); + } + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 694: case 695: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-5].suggestFilters }; +break; +case 696: case 697: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-4].suggestFilters }; +break; +case 698: + + if ($$[$0-2].types[0] === $$[$0].types[0] && !$$[$0-5].typeSet) { + parser.applyTypeToSuggestions($$[$0-2]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-5].suggestFilters }; + +break; +case 699: + + if ($$[$0-5].types[0] === $$[$0].types[0] && !$$[$0-2].typeSet) { + parser.applyTypeToSuggestions($$[$0-5]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }; + +break; +case 700: + + if ($$[$0-5].types[0] === $$[$0-2].types[0] && !$$[$0].typeSet) { + parser.applyTypeToSuggestions($$[$0-5]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 701: + + parser.valueExpressionSuggest($$[$0-5], $$[$0-1]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 702: case 708: + + parser.suggestValueExpressionKeywords($$[$0-1], ['AND']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 703: + + parser.valueExpressionSuggest($$[$0-3], $$[$0-2] + ' ' + $$[$0-1]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 704: + + if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0-4].typeSet) { + parser.applyTypeToSuggestions($$[$0-4]) + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-4].suggestFilters }; + +break; +case 705: + + if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0-2].typeSet) { + parser.applyTypeToSuggestions($$[$0-4]) + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }; + +break; +case 706: + + if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0].typeSet) { + parser.applyTypeToSuggestions($$[$0-4]) + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 707: + + parser.valueExpressionSuggest($$[$0-4], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-4]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 709: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 710: case 712: case 714: case 716: + + parser.valueExpressionSuggest(undefined, $$[$0-1]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true, suggestFilters: true }; + +break; +case 711: case 715: + + parser.addColRefIfExists($$[$0]); + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters } + +break; +case 713: case 717: + + parser.addColRefIfExists($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters } + +break; +case 718: case 719: + + parser.valueExpressionSuggest(undefined, $$[$0-1]); + parser.applyTypeToSuggestions({ types: [ 'NUMBER' ] }); + this.$ = { types: [ 'NUMBER' ], typeSet: true }; + +break; +case 720: case 721: case 722: + + if (!$$[$0-2].typeSet) { + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + parser.addColRefIfExists($$[$0]); + } + this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0-2].suggestFilters } + +break; +case 723: case 724: case 725: + + parser.valueExpressionSuggest(undefined, $$[$0-1]); + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + this.$ = { types: [ 'NUMBER' ], typeSet: true }; + +break; +case 726: case 727: case 728: + + if (!$$[$0].typeSet) { + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + parser.addColRefIfExists($$[$0-2]); + } + this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 729: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-1].suggestFilters }; +break; +case 730: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }; +break; +case 733: + + parser.valueExpressionSuggest(undefined, $$[$0]); + parser.applyTypeToSuggestions({ types: [ 'STRING' ] }); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 734: + + parser.valueExpressionSuggest(undefined, $$[$0-1] + ' ' + $$[$0]); + parser.applyTypeToSuggestions({ types: [ 'STRING' ] }); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 736: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { types: [ 'T' ], typeSet: true }; + +break; +case 738: + + parser.suggestValueExpressionKeywords($$[$0-2], ['WHEN']); + this.$ = { types: [ 'T' ], typeSet: true }; + +break; +case 739: + + this.$ = $$[$0]; + this.$.suggestFilters = $$[$0-1].suggestFilters; + +break; +case 740: +this.$ = { types: [ 'T' ], suggestFilters: $$[$0-1].suggestFilters }; +break; +case 742: case 744: + + $$[$0].position = 1; + +break; +case 743: + + $$[$0].position = $$[$0-2].position + 1; + this.$ = $$[$0]; + +break; +case 745: + + $$[$0-2].position += 1; + +break; +case 746: + + $$[$0-2].position = 1; + +break; +case 747: + + $$[$0-4].position += 1; + +break; +case 748: + + parser.valueExpressionSuggest(); + $$[$0-2].position += 1; + +break; +case 749: + + parser.valueExpressionSuggest(); + $$[$0-4].position += 1; + +break; +case 750: + + parser.suggestValueExpressionKeywords($$[$0-3]); + +break; +case 751: case 752: + + parser.valueExpressionSuggest(); + this.$ = { cursorAtStart : true, position: 1 }; + +break; +case 753: case 754: + + parser.valueExpressionSuggest(); + this.$ = { position: 2 }; + +break; +case 757: + + var lastLoc = parser.yy.locations[parser.yy.locations.length - 1]; + if (lastLoc.type !== 'variable') { + lastLoc.type = 'column'; + } + // used for function references with db prefix + var firstLoc = parser.yy.locations[parser.yy.locations.length - $$[$0].length]; + this.$ = { chain: $$[$0], firstLoc: firstLoc, lastLoc: lastLoc } + +break; +case 764: + + parser.suggestValues($$[$0]); + +break; +case 765: +this.$ = { types: [ 'NUMBER' ], text: $$[$0] }; +break; +case 771: case 773: case 774: +this.$ = $$[$0-1] + $$[$0]; +break; +case 772: case 775: +this.$ = $$[$0-2] + $$[$0-1] + $$[$0]; +break; +case 776: +this.$ = $$[$0-3] + $$[$0-2] + $$[$0-1] + $$[$0]; +break; +case 777: + + if (/\$\{[^}]*\}/.test($$[$0])) { + parser.addVariableLocation(_$[$0], $$[$0]); + this.$ = { types: [ 'STRING' ], columnReference: [{ name: $$[$0] }], text: "'" + $$[$0] + "'" } + } else { + this.$ = { types: [ 'STRING' ] } + } + +break; +case 778: + + if (/\$\{[^}]*\}/.test($$[$0])) { + parser.addVariableLocation(_$[$0], $$[$0]); + this.$ = { types: [ 'STRING' ], columnReference: [{ name: $$[$0] }], text: '"' + $$[$0] + '"' } + } else { + this.$ = { types: [ 'STRING' ], text: '"' + $$[$0] + '"' } + } + +break; +case 779: +this.$ = { types: [ 'BOOLEAN' ], text: $$[$0] }; +break; +case 780: + + this.$ = { partialQuote: '\'', missingEndQuote: parser.yy.missingEndQuote }; + +break; +case 781: + + this.$ = { partialQuote: '"', missingEndQuote: parser.yy.missingEndQuote }; + +break; +case 788: + + this.$ = $$[$0]; + + if (parser.yy.latestTablePrimaries.length > 0) { + var idx = parser.yy.latestTablePrimaries.length - 1; + var tables = []; + do { + var tablePrimary = parser.yy.latestTablePrimaries[idx]; + if (!tablePrimary.subQueryAlias) { + tables.unshift(tablePrimary.alias ? { identifierChain: tablePrimary.identifierChain, alias: tablePrimary.alias } : { identifierChain: tablePrimary.identifierChain }) + } + idx--; + } while (idx >= 0 && tablePrimary.join && !tablePrimary.subQueryAlias) + + if (tables.length > 0) { + this.$.suggestJoins = { + prependJoin: true, + tables: tables + }; + } + } + +break; +case 795: + + this.$ = { + primary: $$[$0-1] + } + if ($$[$0-1].identifierChain) { + if ($$[$0]) { + $$[$0-1].alias = $$[$0].alias + parser.addTableAliasLocation($$[$0].location, $$[$0].alias, $$[$0-1].identifierChain); + } + parser.addTablePrimary($$[$0-1]); + } + + var keywords = []; + if (!$$[$0]) { + keywords = ['AS']; + } else if ($$[$0].suggestKeywords) { + keywords = $$[$0].suggestKeywords; + } + if (keywords.length > 0) { + this.$.suggestKeywords = keywords; + } + +break; +case 796: + + this.$ = { + primary: $$[$0-1] + }; + + if ($$[$0]) { + this.$.primary.alias = $$[$0].alias; + parser.addTablePrimary({ subQueryAlias: $$[$0].alias }); + parser.addSubqueryAliasLocation($$[$0].location, $$[$0].alias, $$[$0-1].identifierChain); + } + + var keywords = []; + if (!$$[$0]) { + keywords = ['AS']; + } + if (keywords.length > 0) { + this.$.suggestKeywords = keywords; + } + +break; +case 797: + + if ($$[$0]) { + parser.addTableAliasLocation($$[$0].location, $$[$0].alias, $$[$0-1].identifierChain); + } + +break; +case 798: + + if ($$[$0]) { + parser.addTablePrimary({ subQueryAlias: $$[$0].alias }); + parser.addSubqueryAliasLocation($$[$0].location, $$[$0].alias); + } + +break; +case 808: + + parser.pushQueryState(); + +break; +case 809: + + parser.popQueryState(); + +break; +case 811: + + if ($$[$0-1]) { + $$[$0-2].alias = $$[$0-1].alias; + parser.addTablePrimary({ subQueryAlias: $$[$0-1].alias }); + parser.addSubqueryAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-2].identifierChain); + } + this.$ = $$[$0-2]; + +break; +case 814: + + var subQuery = parser.getSubQuery($$[$0]); + subQuery.columns.forEach(function (column) { + parser.expandIdentifierChain({ wrapper: column }); + delete column.linked; + }); + parser.popQueryState(subQuery); + this.$ = subQuery; + +break; +case 831: case 832: case 833: case 834: +this.$ = { alias: $$[$0], location: _$[$0] }; +break; +case 841: case 842: + + if (parser.yy.result.suggestFunctions) { + parser.suggestAggregateFunctions(); + } + +break; +case 843: + + if (!$$[$0-2] && !$$[$0-1]) { + parser.suggestKeywords([{ value: 'PARTITION BY', weight: 2 }, { value: 'ORDER BY', weight: 1 }]); + } else if (!$$[$0-2]) { + parser.suggestKeywords(['PARTITION BY']); + } + +break; +case 844: + + if (!$$[$0-1]) { + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'ORDER BY', weight: 2 }]); + } else { + parser.suggestValueExpressionKeywords($$[$0-3]); + } + +break; +case 848: + + parser.suggestKeywords(['BY']); + +break; +case 853: + + // Only allowed in last order by + delete parser.yy.result.suggestAnalyticFunctions; + +break; +case 854: + + var keywords = []; + if ($$[$0-2].suggestKeywords) { + keywords = parser.createWeightedKeywords($$[$0-2].suggestKeywords, 2); + } + if (!$$[$0]) { + keywords = keywords.concat([{ value: 'RANGE BETWEEN', weight: 1 }, { value: 'ROWS BETWEEN', weight: 1 }]); + } + parser.suggestKeywords(keywords); + +break; +case 860: + + parser.suggestKeywords(['BETWEEN']); + +break; +case 861: + + if (!$$[$0-2] && !$$[$0-1]) { + parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED PRECEDING']); + } else if (!$$[$0-1]) { + parser.suggestKeywords(['AND']); + } + +break; +case 866: + + lexer.popState(); + +break; +case 867: + + lexer.begin('hdfs'); + +break; +case 869: + + parser.suggestHdfs({ path: $$[$0-3] }); + +break; +case 870: + + parser.suggestHdfs({ path: $$[$0-2] }); + +break; +case 871: + + parser.suggestHdfs({ path: $$[$0-1] }); + +break; +case 872: + + parser.suggestHdfs({ path: '' }); + +break; +case 873: + + parser.suggestHdfs({ path: '' }); + +break; +case 879: + + parser.suggestKeywords(['PRECEDING']); + +break; +case 880: case 885: + + parser.suggestKeywords(['ROW']); + +break; +case 884: + + parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED FOLLOWING']); + +break; +case 886: + + parser.suggestKeywords(['FOLLOWING']); + +break; +case 890: +this.$ = { inValueEdit: true }; +break; +case 891: +this.$ = { inValueEdit: true, cursorAtStart: true }; +break; +case 892: case 893: case 894: + + this.$ = { suggestKeywords: ['NOT'] } + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 898: case 899: case 900: + + parser.suggestFunctions({ types: [ 'STRING' ] }); + parser.suggestColumns({ types: [ 'STRING' ] }); + this.$ = { types: ['BOOLEAN'] } + +break; +case 901: + + this.$ = parser.findCaseType($$[$0-1]) + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 902: + + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + parser.extractExpressionText(this.$, $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 903: +this.$ = parser.findCaseType($$[$0-1]); +break; +case 904: + + parser.suggestValueExpressionKeywords($$[$0-1], ['END']); + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 905: + + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 906: +this.$ = parser.findCaseType($$[$0-2]); +break; +case 907: + + if ($$[$0].toLowerCase() !== 'end') { + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'END', weight: 3 }, { value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } else { + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 908: + + if ($$[$0].toLowerCase() !== 'end') { + parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'END', weight: 3 }, { value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } else { + parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } + this.$ = parser.findCaseType($$[$0-2]); + +break; +case 909: + + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + this.$.suggestFilters = $$[$0-1].suggestFilters + +break; +case 910: + + parser.valueExpressionSuggest(); + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 911: + + parser.valueExpressionSuggest(); + this.$ = { types: [ 'T' ], typeSet: true }; + +break; +case 912: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = $$[$0-1]; + +break; +case 913: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { types: [ 'T' ] }; + +break; +case 916: + + this.$ = { caseTypes: [ $$[$0] ], lastType: $$[$0] } + parser.extractExpressionText(this.$, $$[$0]); + +break; +case 917: + + $$[$0-1].caseTypes.push($$[$0]); + this.$ = { caseTypes: $$[$0-1].caseTypes, lastType: $$[$0] }; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 921: + + parser.suggestValueExpressionKeywords($$[$0-2], ['WHEN']); + +break; +case 923: + + this.$ = $$[$0] + parser.extractExpressionText(this.$, $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 924: +this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0].suggestFilters }; +break; +case 925: +this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0-1].suggestFilters }; +break; +case 926: +this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0-2].suggestFilters }; +break; +case 927: case 928: +this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0].suggestFilters }; +break; +case 929: + + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 930: + + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [$$[$0]] }; + +break; +case 931: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 932: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 933: case 935: + + parser.valueExpressionSuggest(); + this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true }; + +break; +case 934: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['THEN']); + this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true }; + +break; +case 936: + + parser.valueExpressionSuggest(); + this.$ = { caseTypes: [$$[$0]], suggestFilters: true }; + +break; +case 937: + + parser.suggestValueExpressionKeywords($$[$0-1], ['THEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 938: + + parser.suggestValueExpressionKeywords($$[$0-2], ['THEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 939: case 940: case 941: case 942: + + parser.valueExpressionSuggest(); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +} +}, +table: [o($V0,$V1,{195:1,116:2}),{1:[3]},o($V2,$V3,{174:3,196:4,175:6,176:7,178:8,3:119,23:120,4:121,9:124,5:126,12:130,10:131,2:$V4,7:$V5,8:$V6,13:$V7,17:$V8,20:$V9,22:$Va,27:$Vb,35:$Vc,36:$Vd,50:$Ve,63:$Vf,64:$Vg,65:$Vh,66:$Vi,67:$Vj,68:$Vk,69:$Vl,70:$Vm,71:$Vn,75:$Vo,77:$Vp,81:$Vq,88:$Vr,89:$Vs,90:$Vt,99:$Vu,100:$Vv,106:$Vw,115:$Vx,117:$Vy,141:$Vz,142:$VA,143:$VB,144:$VC,145:$VD,146:$VE,147:$VF,148:$VG,149:$VH,150:$VI,151:$VJ,153:$VK,154:$VL,155:$VM,157:$VN,163:$VO,171:$VP,179:$VQ,180:$VR,181:$VS,185:$VT,187:$VU,197:$VV,198:$VW,200:$VX,201:$VY,202:$VZ,203:$V_,204:$V$,205:$V01,206:$V11,207:$V21,208:$V31,209:$V41,210:$V51,211:$V61,212:$V71,213:$V81,214:$V91,215:$Va1,216:$Vb1,217:$Vc1,218:$Vd1,219:$Ve1,220:$Vf1,221:$Vg1,222:$Vh1,223:$Vi1,224:$Vj1,225:$Vk1,226:$Vl1,227:$Vm1,228:$Vn1,229:$Vo1,230:$Vp1,231:$Vq1,232:$Vr1,233:$Vs1,234:$Vt1,235:$Vu1,236:$Vv1,237:$Vw1,238:$Vx1,239:$Vy1,240:$Vz1,241:$VA1,242:$VB1,243:$VC1,244:$VD1,245:$VE1,246:$VF1,247:$VG1,248:$VH1,249:$VI1,250:$VJ1,251:$VK1,252:$VL1,253:$VM1,254:$VN1,255:$VO1,256:$VP1,257:$VQ1,258:$VR1,259:$VS1,260:$VT1,261:$VU1,263:$VV1}),{177:[1,134],194:[1,133]},{194:[1,135]},o($V2,[2,333]),{2:[1,136]},o($V2,[2,336]),{177:[1,137],194:[2,364]},{2:[2,377]},{2:[2,378]},{2:[2,379]},{2:[2,380]},{2:[2,381]},{2:[2,382]},{2:[2,383]},{2:[2,384]},{2:[2,385]},{2:[2,386]},{2:[2,387]},{2:[2,388]},{2:[2,389]},{2:[2,390]},{2:[2,391]},{2:[2,392]},{2:[2,393]},{2:[2,394]},{2:[2,395]},{2:[2,396]},{2:[2,397]},{2:[2,398]},{2:[2,399]},{2:[2,400]},{2:[2,401]},{2:[2,402]},{2:[2,403]},{2:[2,404]},{2:[2,405]},{2:[2,406]},{2:[2,407]},{2:[2,408]},{2:[2,409]},{2:[2,410]},{2:[2,411]},{2:[2,412]},{2:[2,413]},{2:[2,414]},{2:[2,415]},{2:[2,416]},{2:[2,417]},{2:[2,418]},{2:[2,419]},{2:[2,420]},{2:[2,421]},{2:[2,422]},{2:[2,423]},{2:[2,424]},{2:[2,425]},{2:[2,426]},{2:[2,427]},{2:[2,428]},{2:[2,429]},{2:[2,430]},{2:[2,431]},{2:[2,432]},{2:[2,433]},{2:[2,434]},{2:[2,435]},{2:[2,436]},{2:[2,437]},{2:[2,438]},{2:[2,439]},{2:[2,440]},{2:[2,441]},{2:[2,442]},{2:[2,443]},{2:[2,444]},{2:[2,445]},{2:[2,446]},{2:[2,447]},{2:[2,448]},{2:[2,449]},{2:[2,450]},{2:[2,451]},{2:[2,452]},{2:[2,453]},{2:[2,454]},{2:[2,455]},{2:[2,456]},{2:[2,457]},{2:[2,458]},{2:[2,459]},{2:[2,460]},{2:[2,461]},{2:[2,462]},{2:[2,463]},{2:[2,464]},{2:[2,465]},{2:[2,466]},{2:[2,467]},{2:[2,468]},{2:[2,469]},{2:[2,470]},{2:[2,471]},{2:[2,472]},{2:[2,473]},{2:[2,474]},{2:[2,475]},{2:[2,476]},{2:[2,477]},{2:[2,478]},{2:[2,479]},{2:[2,480]},{2:[2,481]},{2:[2,482]},{2:[2,483]},{2:[2,484]},o($V2,[2,368]),o($V2,[2,369]),o($V2,[2,370]),o($V2,[2,339],{2:[1,138]}),{5:140,7:$VW1,10:142,22:[1,139],90:$Vt},o($V2,[2,341]),o($V2,[2,342]),o($V2,[2,343]),o($V2,[2,344]),o($VX1,$VY1,{6:143,11:144,111:145,112:146,113:147,114:148,115:$VZ1}),o([2,8,17,27,35,50,75,81,115,117,177,194,240],$V_1),o([2,7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,106,115,117,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,177,187,194,200,201,202,203,204,205,206,207,208,211,212,213,214,215,218,220,225,226,227,228,229,233,237,238,239,240,244,245,249,253,256,257,258,261,326],[2,488]),{14:150,15:151,16:152,18:153,19:154,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},o($V52,[2,7],{5:164,7:[1,163],90:$V62}),o($V52,$VY1,{113:147,6:166,111:167,115:$V72}),o([2,7,22,77,106,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,183,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258,263],$V82,{91:169,99:$V92,100:$Va2}),{1:[2,361]},o($V0,$V1,{116:172}),{1:[2,362]},o($V2,[2,334]),o($Vb2,$V1,{116:173}),o($V2,[2,338]),o($V2,[2,340]),o($VX1,$VY1,{111:145,112:146,113:147,114:148,6:174,11:175,115:$VZ1}),{3:176,4:178,5:126,9:177,10:131,12:130,13:$V7,90:$Vt},o($V52,$VY1,{113:147,111:167,6:179,115:$V72}),o($V52,[2,3]),o($V52,[2,11]),o($VX1,$Vc2,{113:180,114:181,115:$VZ1}),o($V52,[2,215]),o($Vd2,[2,216]),o($V52,[2,218],{113:147,111:182,115:$V72}),o([22,90,99,100],$V1,{116:183}),o([7,22,90],$Ve2,{17:[1,184]}),o($Vf2,[2,13]),o($Vg2,[2,14]),o($Vf2,[2,16],{17:[1,185]}),{20:[1,186],22:[1,187]},o($Vh2,[2,581]),{214:$Vi2,266:$Vj2},o($Vh2,[2,374]),o($Vh2,[2,375]),o($Vh2,[2,376]),o($Vh2,[2,371]),o($Vh2,[2,372]),o($Vh2,[2,373]),{3:190,4:191,5:192,13:$Vk2,90:$V62},o($V52,$VY1,{113:147,111:167,6:194,115:$V72}),o([2,7,77,106,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,183,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258],$V82,{91:195,99:$V92,100:$Va2}),o($V52,[2,10]),o($V52,$Vc2,{113:180,115:$V72}),o([90,99,100],$V1,{116:196}),{2:$Vl2,7:$Vm2,19:254,22:[1,200],23:210,45:205,46:209,76:248,77:$V$1,92:197,94:198,96:199,98:201,103:202,104:204,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,182:203,183:$VF2,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VT2,[2,162]),o($VT2,[2,163]),o($V2,$V3,{175:6,176:7,3:119,23:120,4:121,9:124,5:126,12:130,10:131,174:280,178:281,2:$V4,7:$V5,8:$V6,13:$V7,17:$V8,20:$V9,22:$Va,27:$Vb,35:$Vc,36:$Vd,50:$Ve,63:$Vf,64:$Vg,65:$Vh,66:$Vi,67:$Vj,68:$Vk,69:$Vl,70:$Vm,71:$Vn,75:$Vo,77:$Vp,81:$Vq,88:$Vr,89:$Vs,90:$Vt,99:$Vu,100:$Vv,106:$Vw,115:$Vx,117:$Vy,141:$Vz,142:$VA,143:$VB,144:$VC,145:$VD,146:$VE,147:$VF,148:$VG,149:$VH,150:$VI,151:$VJ,153:$VK,154:$VL,155:$VM,157:$VN,163:$VO,171:$VP,179:$VQ,180:$VR,181:$VS,185:$VT,187:$VU,197:$VV,198:$VW,200:$VX,201:$VY,202:$VZ,203:$V_,204:$V$,205:$V01,206:$V11,207:$V21,208:$V31,209:$V41,210:$V51,211:$V61,212:$V71,213:$V81,214:$V91,215:$Va1,216:$Vb1,217:$Vc1,218:$Vd1,219:$Ve1,220:$Vf1,221:$Vg1,222:$Vh1,223:$Vi1,224:$Vj1,225:$Vk1,226:$Vl1,227:$Vm1,228:$Vn1,229:$Vo1,230:$Vp1,231:$Vq1,232:$Vr1,233:$Vs1,234:$Vt1,235:$Vu1,236:$Vv1,237:$Vw1,238:$Vx1,239:$Vy1,240:$Vz1,241:$VA1,242:$VB1,243:$VC1,244:$VD1,245:$VE1,246:$VF1,247:$VG1,248:$VH1,249:$VI1,250:$VJ1,251:$VK1,252:$VL1,253:$VM1,254:$VN1,255:$VO1,256:$VP1,257:$VQ1,258:$VR1,259:$VS1,260:$VT1,261:$VU1,263:$VV1}),o($V2,$V3,{175:6,176:7,3:119,4:191,5:192,174:282,2:$V4,7:$V5,8:$V6,13:$Vk2,17:$V8,20:$V9,27:$Vb,35:$Vc,36:$Vd,50:$Ve,63:$Vf,64:$Vg,65:$Vh,66:$Vi,67:$Vj,68:$Vk,69:$Vl,70:$Vm,71:$Vn,75:$Vo,77:$Vp,81:$Vq,88:$Vr,89:$Vs,90:$V62,99:$Vu,100:$Vv,106:$Vw,115:$Vx,117:$Vy,141:$Vz,142:$VA,143:$VB,144:$VC,145:$VD,146:$VE,147:$VF,148:$VG,149:$VH,150:$VI,151:$VJ,153:$VK,154:$VL,155:$VM,157:$VN,163:$VO,171:$VP,185:$VT,187:$VU,197:$VV,198:$VW,200:$VX,201:$VY,202:$VZ,203:$V_,204:$V$,205:$V01,206:$V11,207:$V21,208:$V31,209:$V41,210:$V51,211:$V61,212:$V71,213:$V81,214:$V91,215:$Va1,216:$Vb1,217:$Vc1,218:$Vd1,219:$Ve1,220:$Vf1,221:$Vg1,222:$Vh1,223:$Vi1,224:$Vj1,225:$Vk1,226:$Vl1,227:$Vm1,228:$Vn1,229:$Vo1,230:$Vp1,231:$Vq1,232:$Vr1,233:$Vs1,234:$Vt1,235:$Vu1,236:$Vv1,237:$Vw1,238:$Vx1,239:$Vy1,240:$Vz1,241:$VA1,242:$VB1,243:$VC1,244:$VD1,245:$VE1,246:$VF1,247:$VG1,248:$VH1,249:$VI1,250:$VJ1,251:$VK1,252:$VL1,253:$VM1,254:$VN1,255:$VO1,256:$VP1,257:$VQ1,258:$VR1,259:$VS1,260:$VT1,261:$VU1}),o($V52,[2,1]),o($V52,[2,6]),{8:[1,283]},{8:[1,284]},{5:140,7:$VW1,10:142,90:$Vt},o($V52,[2,5]),o($Vd2,[2,217]),o($V52,[2,219],{113:147,111:285,115:$V72}),o($V52,[2,220],{113:180,115:$V72}),{22:[1,287],90:$V82,91:286,99:$V92,100:$Va2},{16:288,18:289,19:154,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{14:290,16:152,19:291,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{7:[1,292]},o($VU2,[2,21]),{214:[1,293]},o($Vh2,[2,583]),{8:[1,294]},{5:295,7:[1,296],90:$V62},o($V52,$VY1,{6:143,113:147,111:167,115:$V72}),{14:297,16:152,19:291,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},o($V52,[2,9]),{2:$Vl2,7:$VV2,19:254,45:301,76:248,77:$V$1,92:298,94:299,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,182:300,183:$VF2,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{90:$V82,91:321,99:$V92,100:$Va2},o($V63,$V73,{93:322,97:324,26:327,29:328,17:[1,326],22:[1,325],27:$V83,95:$V93}),{26:327,27:$V83,29:328,93:330,97:331},o($Vd2,[2,151],{93:332,26:333,27:$Va3}),o($Vd2,[2,152],{169:155,199:159,103:202,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,45:301,160:309,152:310,316:311,121:312,123:313,138:316,26:333,93:335,92:336,327:346,7:$VV2,17:$Vb3,20:$V_1,27:$Va3,77:$V$1,106:$Vc3,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{26:333,27:$Va3,93:351},o($Vo3,[2,168]),{17:[1,352],27:$Vp3},o($Vq3,[2,170],{17:[1,353]}),o([8,17,22,27,95,115,177,194],$Vr3,{169:155,199:159,105:354,107:355,327:369,331:370,19:371,271:372,294:374,272:375,265:380,269:381,267:382,270:383,20:$Vs3,77:$V$1,106:$Vt3,187:$Vu3,200:$V02,201:$V12,202:$V22,203:$V32,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,214:$VA3,215:$VB3,220:$VC3,225:$VL2,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,249:$VP2}),o($Vo3,$VK3),o($VL3,[2,357]),{17:[1,384]},o($VM3,$Vr3,{169:155,199:159,19:371,271:372,265:380,269:381,105:385,327:398,20:$VN3,77:$V$1,106:$VO3,187:$VP3,200:$V02,201:$V12,202:$V22,203:$V32,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,214:$V42,215:$VV3,220:$VW3,225:$V23,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,249:$V53}),{20:$V_3},o($V$3,[2,625]),{7:$Vm2,19:254,22:[1,403],45:401,46:402,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:406,45:404,46:405,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V14,45:408,46:409,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:[1,410],265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V14,45:412,46:413,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:[1,414],265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$V24,324:415,329:416},{7:$Vm2,19:254,22:[1,420],45:418,46:419,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:[1,424],45:422,46:425,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,226:$V34,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,261:$V44,265:260,267:263,269:261,270:264,303:242,316:228,317:241,328:421,332:423,338:236,339:240,340:249,341:253,342:258,343:259,344:262,392:426,393:427,394:429,395:430},o($V54,[2,655]),o($V$3,$V64,{161:432,165:433,7:$V74}),{7:$V74,161:435,165:436},o($V$3,[2,296]),o($V$3,[2,297]),o($V$3,[2,299]),o($V54,[2,302]),o($V54,[2,303]),o($V54,[2,304]),o($V84,$V94,{206:[1,437]}),{7:[2,278]},{7:[2,279]},{7:[2,280]},{7:[2,281]},o($V$3,$Va4,{122:438,128:439,124:440,130:441,171:$Vb4}),{22:[1,444],124:443,130:445,171:$Vb4},o($V$3,[2,235]),o($V$3,[2,763]),o($V54,[2,236]),o($V54,[2,238],{124:446,171:$Vc4}),o($V54,[2,242]),o($V54,[2,764]),o($V54,[2,759]),o($Vd4,[2,595]),o($Ve4,[2,243]),o($Ve4,[2,244]),o($Ve4,[2,245]),{7:[1,448]},{7:[1,449]},o($V$3,[2,765]),o($V$3,[2,766]),o($V54,[2,246]),o($V54,[2,247]),o($V54,[2,248]),o($V54,[2,767]),o($Vd4,[2,605]),{7:[1,450]},{7:[1,451]},{7:[1,452]},o($V$3,[2,768]),o($V$3,[2,769]),o($V$3,[2,777]),o($V$3,[2,778]),o($V$3,[2,779]),o($V54,[2,780]),o($V54,[2,781]),{7:[2,254]},{7:[2,255]},{7:[2,256]},{7:[2,257]},{7:[2,258]},{7:[2,259]},{7:[2,260]},{7:[2,261]},o($V$3,[2,770],{206:[1,453]}),{257:[1,454],258:[1,455]},{257:[1,456]},{249:$Vf4,266:$Vg4,268:[1,459]},{225:$Vh4,266:$Vi4,268:[1,462]},o($V$3,[2,782]),o($V$3,[2,783]),o($V2,[2,337]),{177:[1,464],194:[2,366]},{177:$Vj4,194:[2,365]},o($V52,$VY1,{113:147,111:167,6:465,115:$V72}),o($V52,[2,4]),o($V52,[2,221],{113:180,115:$V72}),{5:466,10:467,90:$Vt},o($Vd2,[2,223],{5:468,90:$V62}),o($Vg2,[2,15]),o($Vf2,[2,17],{17:[1,469]}),o($Vf2,[2,18],{17:$Vk4}),{20:[1,471]},o($Vl4,$Vm4,{21:472,23:473,25:474,355:475,22:$Va,263:$VV1}),o($Vh2,[2,582]),o($V52,$Vn4),o($V52,$VY1,{113:147,111:167,6:174,115:$V72}),{3:176,4:191,5:192,13:$Vk2,90:$V62},o([7,90],$Ve2,{17:$Vk4}),o($Vd2,$V73,{93:322,26:333,17:[1,476],27:$Va3,95:$V93}),{26:333,27:$Va3,93:330},{17:[1,477],27:$Vp3},o([2,8,17,27,95,115,177,194],$Vr3,{169:155,199:159,105:354,327:369,19:371,271:372,265:380,269:381,20:$VN3,77:$V$1,106:$Vo4,187:$Vp4,200:$V02,201:$V12,202:$V22,203:$V32,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,214:$V42,215:$Vv4,220:$Vw4,225:$V23,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,249:$V53}),{7:$VV2,19:254,45:491,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:492,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:493,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:494,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VB4,324:415},{7:$VV2,19:254,45:496,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:497,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,261:$VC4,265:260,269:261,303:242,316:311,328:421,338:236,340:249,342:258,343:259,344:262,392:498,394:429},o($VD4,$V64,{161:432,7:$VE4}),{7:$VE4,161:435},o([2,7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,236,237,238,239,243,244,245,247,249,253,261,326],$V94,{206:[1,501]}),o($VD4,$Va4,{122:438,124:440,171:$Vc4}),{124:443,171:$Vc4},{7:[1,502]},{7:[1,503]},{7:[1,504]},{7:[1,505]},{7:[1,506]},{249:$Vf4,266:$Vg4},{225:$Vh4,266:$Vi4},{5:466,90:$V62},o($Vd2,[2,148]),o($Vd2,[2,150]),o($Vd2,[2,153]),o($Vd2,[2,158],{169:155,199:159,103:202,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,45:301,160:309,152:310,316:311,121:312,123:313,138:316,26:333,93:507,92:509,7:$VV2,17:[1,508],27:$Va3,77:$V$1,106:$Vn2,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{2:$Vl2,7:$Vm2,19:254,22:$V04,23:512,45:205,46:209,76:248,77:$V$1,103:510,104:513,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,182:511,183:$VF2,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VF4,$VG4,{101:514,102:516,108:517,109:518,110:519,22:[1,515],117:[1,520]}),o($VH4,$VG4,{101:521,108:522,110:523,117:$VI4}),{7:$V24,19:544,22:[1,526],28:525,30:527,31:528,32:529,56:532,60:534,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,294:545,306:540,307:542,324:541,329:543,345:530,346:531,347:533,348:535,349:536,350:537,351:538,352:539},o($Vd2,[2,149]),o($Vd2,[2,160]),o($Vd2,[2,154]),o($VH4,$VG4,{101:514,108:522,110:523,117:$VI4}),{7:$VB4,19:549,28:546,31:528,56:547,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,306:540,324:541,345:530,347:533,349:536,350:548},o($Vd2,[2,155]),o($Vq3,[2,171],{17:$VJ4}),{7:$VV2,19:254,45:301,76:248,77:$V$1,92:551,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:552,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:553,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:554,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:555,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:556,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:557,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VM3,$VK3,{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:558,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{7:$VV2,19:254,45:559,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V54,[2,733]),{7:$VV2,19:254,45:491,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$V43,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,327:560,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:561,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:562,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:563,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vd2,[2,159]),{7:$Vm2,19:254,22:$VK4,23:566,45:205,46:209,76:248,77:$V$1,92:564,96:565,103:202,104:204,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$VV2,19:254,45:301,76:248,77:$V$1,92:568,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vo3,[2,183]),o($VM3,[2,187]),o($VL4,$VM4,{323:569,22:[1,570],238:[1,571]}),{7:$Vm2,19:254,22:$V04,23:575,45:572,46:574,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:573,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:577,46:579,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:578,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:580,46:582,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:581,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:583,46:585,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:584,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{22:[1,589],215:[1,587],233:[1,586],237:$VF3,244:$VI3,245:$VJ3,327:588,331:590},{7:[1,591],330:592},{7:$Vm2,19:254,22:[1,595],45:593,46:594,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:596,46:598,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:597,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:599,46:601,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:600,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:602,46:604,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:603,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:605,46:607,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:606,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:608,46:610,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:609,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V$3,[2,651]),o($V54,[2,731]),o($VN4,[2,831]),o($VN4,[2,832]),{19:611,22:[1,615],77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,225:$VL2,249:$VP2,265:380,267:382,269:381,270:383,271:612,272:614,294:613},o($VO4,[2,835]),o($VO4,[2,836]),{7:$Vm2,19:254,22:$VP4,45:616,46:617,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,294:620,295:618,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$VP4,45:621,46:622,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,294:620,295:623,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$VP4,45:624,46:625,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,294:620,295:626,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{214:$Vi2,266:$Vj2,268:[1,627]},o($VN4,[2,499]),o($VN4,[2,500]),o($VO4,[2,501]),o($VO4,[2,502]),{2:$VQ4},o($VM3,[2,185]),{7:$VV2,19:254,45:629,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:630,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:631,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:632,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{215:[1,634],233:[1,633],237:$Vj3,244:$Vm3,245:$Vn3,327:635},{7:[1,636]},{7:$VV2,19:254,45:637,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:638,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:639,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:640,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:641,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:642,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V54,[2,729]),{19:611,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,225:$V23,249:$V53,265:380,269:381,271:612},{19:643,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},o($VR4,$VS4,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($VT4,[2,657],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,220:$VW3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VU4,[2,658],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,213:$Vh3,220:$Vi3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VR4,$VW4,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($VT4,[2,659],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,220:$VW3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($V54,[2,660]),o([2,7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,106,115,117,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,177,187,194,200,201,202,203,204,205,206,207,208,211,212,213,214,215,218,220,225,226,227,228,229,233,238,239,249,253,256,257,258,261,326],$V_1,{327:346,237:$Vj3,244:$Vm3,245:$Vn3}),o($VR4,$VX4,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($VT4,[2,661],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,220:$VW3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($V54,[2,662]),{106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3,327:346},o($VZ4,$V_4,{327:369,331:370}),o($V$4,[2,663],{327:398}),o($V54,[2,664]),o($V$3,[2,634]),o($V54,[2,673]),o($Vl4,$Vm4,{355:475,324:541,21:646,350:647,25:648,23:649,7:$VB4,22:$Va,263:$VV1}),{8:$V05,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,327:369,331:370},{2:$V15,8:$V25,24:651,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,327:398},{2:$V15,8:$V25,24:654,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3,327:346},o($V$3,[2,653]),{22:[1,657],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,226:$V34,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,261:$V44,327:369,328:655,331:370,332:656,392:426,393:427,394:429,395:430},o($V54,[2,735]),{2:$V35,7:$VV2,19:254,45:661,76:248,77:$V$1,106:$VV4,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,187:$Vd3,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,226:$V45,227:$V55,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,253:$V65,256:$VQ2,257:$VR2,258:$VS2,261:$VC4,265:260,269:261,303:242,316:311,327:346,328:659,333:658,338:236,340:249,342:258,343:259,344:262,392:498,394:429},{2:$V35,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,227:$V55,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,261:$VC4,327:398,328:665,333:666,392:498,394:429},{22:[1,669],226:[1,668],227:$V75,261:$V44,394:670,395:671},{2:$V35,226:[1,673],227:$V55,333:672},{22:[1,674]},o($V85,[2,916]),o($V95,[2,918],{394:429,392:675,261:$VC4}),{7:$Vm2,19:254,22:[1,679],45:676,46:677,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,253:[1,678],256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V$3,[2,294]),o($V54,[2,300]),{7:$Vm2,8:$Va5,17:$Vb5,19:254,22:$V04,23:682,45:684,46:685,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,139:681,140:683,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V$3,[2,295]),o($V54,[2,301]),{19:254,77:$V$1,106:$Vc5,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,263:$Vd5,294:691,296:689,303:688},o($V$3,[2,233]),o($V54,[2,237]),o($V$3,[2,328]),o($V54,[2,329]),{7:[1,695],19:692,77:$V$1,169:155,172:693,173:694,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},o($V$3,[2,234]),o($V54,[2,240]),o($V54,[2,241]),o($V54,[2,239]),{7:[1,696],19:692,77:$V$1,169:155,172:693,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{7:$Vm2,8:$Ve5,17:$Vb5,19:254,22:$V04,23:699,45:684,46:685,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,139:698,140:700,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,8:$Vf5,19:254,20:[1,705],22:$V04,23:703,45:701,46:704,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o([7,8,17,22,77,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258,263],$V82,{91:706,99:$V92,100:$Va2}),o([7,17,22,77,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258,263],$V82,{91:709,8:$Vg5,99:$V92,100:$Va2,106:$Vh5}),o([7,22,77,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258,263],$V82,{91:710,8:$Vi5,99:$V92,100:$Va2}),o($V$3,[2,771],{257:[1,712],258:[1,713]}),o($V$3,[2,773]),{257:[1,714]},o($V$3,[2,774]),{249:[1,715]},o($Vj5,[2,494]),o($Vk5,[2,495]),{225:[1,716]},o($Vj5,[2,497]),o($Vk5,[2,498]),o($Vb2,$V1,{116:717}),o($Vb2,$V1,{116:718}),o($V52,[2,2]),o($Vd2,[2,222]),o($Vd2,[2,225]),o($Vd2,[2,224]),{14:719,16:152,19:291,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{16:288,19:291,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{7:[1,720]},{8:[1,721]},{2:$V15,8:$V25,24:722},{2:$V15,8:$V25,24:723},{3:738,4:178,5:126,9:739,10:131,12:130,13:$V7,90:$Vt,357:724,358:725,359:726,360:727,361:728,362:729,363:730,364:731,365:732,366:733,367:734,368:735,369:736,370:737},{2:$Vl2,7:$VV2,19:254,45:301,76:248,77:$V$1,103:510,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,182:740,183:$VF2,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:301,76:248,77:$V$1,92:741,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VL4,$VM4,{323:742,238:[1,743]}),{7:$VV2,19:254,45:744,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:745,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:746,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:747,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{215:[1,749],233:[1,748],237:$Vj3,244:$Vm3,245:$Vn3,327:588},{7:[1,750]},{7:$VV2,19:254,45:751,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:752,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:753,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:754,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:755,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:756,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vl5,$VS4,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vl5,$VW4,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vl5,$VX4,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vm5,$V_4,{327:369}),o($Vl4,$Vm4,{324:541,21:646,350:647,355:757,7:$VB4}),{8:$V05,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,327:369},{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,261:$VC4,327:369,328:655,392:498,394:429},{226:[1,758],227:$V75,261:$VC4,394:670},{7:$VV2,19:254,45:759,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,8:$Va5,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:760,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{19:254,77:$V$1,106:$Vc5,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,303:688},{7:$VV2,8:$Ve5,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:762,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,8:$Vf5,19:254,45:763,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o([7,8,77,141,142,143,144,145,146,147,148,149,150,151,153,154,155,156,157,163,200,201,202,203,204,205,206,211,214,218,225,228,229,238,249,256,257,258],$V82,{91:764,99:$V92,100:$Va2}),o($Vn5,$V82,{91:765,8:$Vg5,99:$V92,100:$Va2,106:$Vh5}),o($Vn5,$V82,{91:766,8:$Vi5,99:$V92,100:$Va2}),o($Vd2,[2,156]),{7:$VV2,19:254,26:333,27:$Va3,45:301,76:248,77:$V$1,92:768,93:767,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vq3,[2,174],{17:$VJ4}),o($Vo3,[2,169]),{17:[1,769],27:$Vo5},o($Vq3,[2,176],{169:155,199:159,103:202,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,45:301,160:309,152:310,316:311,121:312,123:313,138:316,92:770,7:$VV2,17:[1,771],20:$V_3,77:$V$1,106:$Vn2,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vq3,[2,177],{17:[1,772]}),o($Vd2,[2,164]),o($Vp5,$VG4,{108:522,110:523,101:773,117:$VI4}),o($Vd2,$Vq5,{52:774,53:775,54:776,55:777,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($Vz5,$VA5,{33:786,38:787,34:788,35:$VB5}),o($VC5,$VA5,{33:790,34:791,35:$VD5}),o($VF4,$VE5,{2:[1,794],22:[1,793]}),{7:$Vm2,19:254,22:[1,796],45:799,46:798,76:248,77:$V$1,118:797,119:795,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($Vd2,[2,165]),o($VC5,$VA5,{34:791,33:800,35:$VD5}),o($Vp5,$VE5),{7:$VV2,19:254,45:801,76:248,77:$V$1,118:797,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o([8,22,35,50,75,81,115,117,177,194],$VF5,{17:[1,802]}),o($VG5,[2,25]),o($VG5,[2,26]),o($VH5,[2,27]),o($VG5,[2,29],{17:[1,803]}),o($VH5,[2,786]),o($VI5,[2,787]),o($VJ5,$VK5,{53:804,62:805,55:806,58:807,59:815,63:$VL5,64:$Vs5,65:$VM5,66:$VN5,67:$VO5,68:$VP5,69:$VQ5,70:$VR5}),o($VH5,[2,789]),o($VI5,[2,790],{53:816,55:817,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($VI5,[2,791]),o($VS5,$Vr3,{169:155,199:159,19:371,271:372,265:380,269:381,105:818,20:$VN3,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,225:$V23,249:$V53}),o([8,17,22,35,50,63,64,65,66,67,68,69,70,71,75,81,115,117,177,194],$Vr3,{169:155,199:159,19:371,271:372,294:374,272:375,265:380,269:381,267:382,270:383,105:819,107:820,20:$Vs3,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,225:$VL2,249:$VP2}),o($VT5,$Vr3,{169:155,199:159,19:371,271:372,265:380,269:381,105:821,20:$VN3,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,225:$V23,249:$V53}),o($VT5,$Vr3,{169:155,199:159,19:371,271:372,265:380,269:381,105:822,20:$VN3,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,225:$V23,249:$V53}),o($VU5,[2,800]),o($VU5,[2,802]),o($VV5,[2,801]),o($VV5,[2,803]),o([8,17,20,22,35,50,63,64,65,66,67,68,69,70,71,75,77,81,115,117,177,194,200,201,202,203,214,225,249],$VW5,{206:[1,823]}),o($VV5,[2,560],{206:[1,824]}),o($VG5,$VF5,{17:$VX5}),o($VI5,$VK5,{55:817,53:826,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($VT5,$Vr3,{169:155,199:159,19:371,271:372,265:380,269:381,105:819,20:$VN3,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,225:$V23,249:$V53}),o($VV5,$VW5,{206:[1,827]}),{7:$VV2,19:254,45:301,76:248,77:$V$1,103:510,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vq3,[2,172],{17:$VJ4}),o($V$4,[2,676],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,677],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,678],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,679],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,710],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,714],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,718],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,719],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V54,[2,734]),o($Vm5,$VY5,{327:369}),o($Vm5,$VZ5,{327:369}),o($Vm5,$V_5,{327:369}),{17:[1,828],22:$V$5,27:$V06},{27:[2,350]},{20:$V_3,27:[2,353]},o([20,27],$V_1,{169:155,199:159,103:202,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,45:301,160:309,152:310,316:311,121:312,123:313,138:316,92:336,327:346,7:$VV2,17:$Vb3,77:$V$1,106:$Vc3,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vq3,[2,173],{17:$VJ4}),{100:[1,833],163:$V16,229:$V26,256:$V36},o($V54,[2,665],{163:[1,834],229:[1,835],256:[1,836]}),o($VL4,$V46,{22:[1,837]}),o($V56,$V66,{327:369,331:370,106:$Vt3,205:$Vv3,213:$Vz3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,684]),o($V76,[2,688],{327:398,106:$VO3,205:$VQ3,213:$VU3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($V54,[2,536]),o($V54,[2,537]),o($V56,$V86,{327:369,331:370,106:$Vt3,205:$Vv3,213:$Vz3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,685]),o($V76,[2,689],{327:398,106:$VO3,205:$VQ3,213:$VU3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($V56,$V96,{327:369,331:370,106:$Vt3,205:$Vv3,213:$Vz3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,686]),o($V76,[2,690],{327:398,106:$VO3,205:$VQ3,213:$VU3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($V56,$Va6,{327:369,331:370,106:$Vt3,205:$Vv3,213:$Vz3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,687]),o($V76,[2,691],{327:398,106:$VO3,205:$VQ3,213:$VU3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),{7:[1,838],330:839},{7:$Vm2,19:254,22:[1,842],45:840,46:841,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V$3,[2,652]),o($V54,[2,656]),o($V54,[2,732]),o($Vl4,$Vm4,{169:155,199:159,159:211,164:219,160:220,152:221,120:222,162:223,126:225,166:226,167:227,316:228,121:233,123:234,125:235,338:236,127:237,129:238,131:239,339:240,317:241,303:242,132:243,133:244,134:245,76:248,340:249,135:250,136:251,137:252,341:253,19:254,138:255,342:258,343:259,265:260,269:261,344:262,267:263,270:264,355:475,21:843,325:844,25:845,334:846,23:847,45:848,46:849,7:$Vm2,17:$Vb6,22:$V04,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1}),o($V54,[2,693]),{22:[1,852],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,326:[1,851],327:369,331:370},{106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,326:[1,853],327:398},o($Vc6,[2,709],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,244:$Vm3,245:$Vn3}),o($Vd6,$Ve6,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,244:$VI3,245:$VJ3}),o($V54,[2,712]),o($Vf6,[2,713],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,244:$Vm3,245:$Vn3}),o($Vd6,$Vg6,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,244:$VI3,245:$VJ3}),o($V54,[2,716]),o($Vf6,[2,717],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,244:$Vm3,245:$Vn3}),o($VZ4,$Vh6,{327:369,331:370,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,723]),o($V$4,[2,726],{327:398,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VZ4,$Vi6,{327:369,331:370,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,724]),o($V$4,[2,727],{327:398,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VZ4,$Vj6,{327:369,331:370,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($V54,[2,725]),o($V$4,[2,728],{327:398,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VN4,[2,833]),o($VN4,[2,834]),o($VO4,[2,837]),o($VO4,[2,838]),o($VO4,[2,839]),o($VZ4,$VY5,{327:369,331:370}),o($V$4,[2,895],{327:398}),o($V54,[2,898]),o([2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,106,115,117,177,187,194,200,201,202,203,205,207,208,212,213,214,215,220,225,226,227,233,238,239,249,253,261,326],[2,538],{327:346,237:$Vj3,244:$Vm3,245:$Vn3}),o($V54,[2,539]),o($VZ4,$VZ5,{327:369,331:370}),o($V$4,[2,896],{327:398}),o($V54,[2,899]),o($VZ4,$V_5,{327:369,331:370}),o($V$4,[2,897],{327:398}),o($V54,[2,900]),o($Vk6,[2,542]),o($VL3,[2,358]),o($V76,[2,680],{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V76,[2,681],{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V76,[2,682],{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V76,[2,683],{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),{7:[1,854]},{7:$VV2,19:254,45:855,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V54,[2,730]),o($Vl4,$Vm4,{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,355:757,325:856,21:857,45:858,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,326:[1,859],327:369},o($Vf6,[2,711],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),o($Vf6,[2,715],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),o($V$4,[2,720],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,721],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V$4,[2,722],{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($VM3,[2,186]),{7:$VV2,19:254,45:558,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{237:$Vj3,244:$Vm3,245:$Vn3,327:560},{8:[1,860]},{8:$Vr3,19:371,20:$VN3,77:$V$1,105:861,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,225:$V23,249:$V53,265:380,269:381,271:372},{2:$V15,8:$V25,24:862},{2:$V15,8:$V25,24:863},o($V$3,[2,635]),o($V54,[2,674]),o($Vl6,[2,543]),o($Vl6,[2,544]),o($V54,[2,675]),o($V$3,[2,654]),o($V54,[2,737]),{2:$V35,7:$VV2,19:254,45:661,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,226:$V45,227:$V55,228:$V33,229:$VN2,238:$V43,249:$V53,253:$V65,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,333:864,338:236,340:249,342:258,343:259,344:262},o($V54,[2,736]),o($V54,[2,741]),{2:$V35,7:$VV2,19:254,45:865,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,227:$V55,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,333:866,338:236,340:249,342:258,343:259,344:262},{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,253:$Vm6,327:369},o($Vn6,[2,931],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:868,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($V54,[2,914]),o($V54,[2,915]),o($V54,[2,739]),o($V54,[2,740]),o($V$3,[2,901]),{7:$Vm2,19:254,22:[1,871],45:869,46:870,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{2:$V35,7:$VV2,19:254,45:872,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,227:$V55,228:$V33,229:$VN2,238:$V43,249:$V53,253:$V65,256:$VQ2,257:$VR2,258:$VS2,261:$VC4,265:260,269:261,303:242,316:311,333:873,338:236,340:249,342:258,343:259,344:262,392:874,394:429},o($V85,[2,917]),o($V95,[2,919],{394:429,392:875,261:$VC4}),o($V54,[2,903]),{2:$V35,7:$VV2,19:254,45:876,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,227:$V55,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,333:877,338:236,340:249,342:258,343:259,344:262},{2:$V35,227:$V55,333:878},o($V95,[2,922],{394:670,261:$VC4}),{22:[1,880],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,253:[1,879],327:369,331:370},o($Vn6,[2,924],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,253:[1,881]}),{7:$Vm2,19:254,22:[1,883],45:884,46:882,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($Vn6,[2,933],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,327:346,45:885,7:$VV2,77:$V$1,106:$VV4,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,253:[1,886],256:$VQ2,257:$VR2,258:$VS2}),o($V$3,[2,309]),{8:$Vo6,17:$Vp6,22:[1,888]},{2:$V15,8:$V25,17:$Vq6,24:890},{2:$V15,8:$V25,24:892},o($Vr6,$Vs6,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($Vn4,[2,316],{327:398,17:[1,893],106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),{22:$Va,23:894,263:$VV1},o($V84,[2,758]),o($Vd4,[2,596]),o($V54,[2,597],{206:[1,895]}),o($Vk6,[2,540]),o($Vk6,[2,541]),o($V$3,[2,330]),o($V$3,[2,331]),o($V54,[2,332]),o($Vt6,$Vu6,{371:896,373:897,23:898,375:900,22:$Va,240:[1,899],263:$VV1}),o($Vt6,$Vu6,{375:900,371:901,240:$Vv6}),o($Vw6,[2,273]),{8:$Vx6,17:$Vp6,22:[1,904]},{2:$V15,8:$V25,17:$Vq6,24:905},{2:$V15,8:$V25,24:906},{20:[1,907],22:[1,908],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,327:369,331:370},o($V$3,[2,283]),{2:$V15,8:$V25,20:[1,909],24:910},{2:$V15,8:$V25,20:[1,911],24:912,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,327:398},{22:[1,913]},{7:$Vm2,8:$Vy6,17:$Vb5,19:254,22:$V04,23:916,45:684,46:685,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,139:915,140:917,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{8:[1,918]},o($Ve4,[2,263]),{7:$Vm2,17:$Vb5,19:254,22:$V04,23:920,45:684,46:685,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,139:919,140:921,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:923,45:922,46:924,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($Ve4,[2,269]),o($V$3,[2,772]),{257:[1,925]},o($V$3,[2,775]),o($Vj5,[2,493]),o($Vj5,[2,496]),o($V2,$V3,{175:6,176:7,3:119,4:191,5:192,174:280,2:$V4,7:$V5,8:$V6,13:$Vk2,17:$V8,20:$V9,27:$Vb,35:$Vc,36:$Vd,50:$Ve,63:$Vf,64:$Vg,65:$Vh,66:$Vi,67:$Vj,68:$Vk,69:$Vl,70:$Vm,71:$Vn,75:$Vo,77:$Vp,81:$Vq,88:$Vr,89:$Vs,90:$V62,99:$Vu,100:$Vv,106:$Vw,115:$Vx,117:$Vy,141:$Vz,142:$VA,143:$VB,144:$VC,145:$VD,146:$VE,147:$VF,148:$VG,149:$VH,150:$VI,151:$VJ,153:$VK,154:$VL,155:$VM,157:$VN,163:$VO,171:$VP,185:$VT,187:$VU,197:$VV,198:$VW,200:$VX,201:$VY,202:$VZ,203:$V_,204:$V$,205:$V01,206:$V11,207:$V21,208:$V31,209:$V41,210:$V51,211:$V61,212:$V71,213:$V81,214:$V91,215:$Va1,216:$Vb1,217:$Vc1,218:$Vd1,219:$Ve1,220:$Vf1,221:$Vg1,222:$Vh1,223:$Vi1,224:$Vj1,225:$Vk1,226:$Vl1,227:$Vm1,228:$Vn1,229:$Vo1,230:$Vp1,231:$Vq1,232:$Vr1,233:$Vs1,234:$Vt1,235:$Vu1,236:$Vv1,237:$Vw1,238:$Vx1,239:$Vy1,240:$Vz1,241:$VA1,242:$VB1,243:$VC1,244:$VD1,245:$VE1,246:$VF1,247:$VG1,248:$VH1,249:$VI1,250:$VJ1,251:$VK1,252:$VL1,253:$VM1,254:$VN1,255:$VO1,256:$VP1,257:$VQ1,258:$VR1,259:$VS1,260:$VT1,261:$VU1}),o($V2,$V3,{175:6,176:7,3:119,4:191,5:192,174:926,2:$V4,7:$V5,8:$V6,13:$Vk2,17:$V8,20:$V9,27:$Vb,35:$Vc,36:$Vd,50:$Ve,63:$Vf,64:$Vg,65:$Vh,66:$Vi,67:$Vj,68:$Vk,69:$Vl,70:$Vm,71:$Vn,75:$Vo,77:$Vp,81:$Vq,88:$Vr,89:$Vs,90:$V62,99:$Vu,100:$Vv,106:$Vw,115:$Vx,117:$Vy,141:$Vz,142:$VA,143:$VB,144:$VC,145:$VD,146:$VE,147:$VF,148:$VG,149:$VH,150:$VI,151:$VJ,153:$VK,154:$VL,155:$VM,157:$VN,163:$VO,171:$VP,185:$VT,187:$VU,197:$VV,198:$VW,200:$VX,201:$VY,202:$VZ,203:$V_,204:$V$,205:$V01,206:$V11,207:$V21,208:$V31,209:$V41,210:$V51,211:$V61,212:$V71,213:$V81,214:$V91,215:$Va1,216:$Vb1,217:$Vc1,218:$Vd1,219:$Ve1,220:$Vf1,221:$Vg1,222:$Vh1,223:$Vi1,224:$Vj1,225:$Vk1,226:$Vl1,227:$Vm1,228:$Vn1,229:$Vo1,230:$Vp1,231:$Vq1,232:$Vr1,233:$Vs1,234:$Vt1,235:$Vu1,236:$Vv1,237:$Vw1,238:$Vx1,239:$Vy1,240:$Vz1,241:$VA1,242:$VB1,243:$VC1,244:$VD1,245:$VE1,246:$VF1,247:$VG1,248:$VH1,249:$VI1,250:$VJ1,251:$VK1,252:$VL1,253:$VM1,254:$VN1,255:$VO1,256:$VP1,257:$VQ1,258:$VR1,259:$VS1,260:$VT1,261:$VU1}),o($Vf2,[2,19],{17:$Vk4}),o($Vl4,$Vm4,{21:472,355:757}),o($Vg2,[2,20]),o($VU2,[2,22]),o($VU2,[2,23]),o($Vn4,[2,814]),o($Vn4,[2,809],{356:927}),o($Vn4,[2,816]),o($Vn4,[2,817]),o($Vn4,[2,818]),o($Vn4,[2,819]),o($Vn4,[2,820]),o($Vn4,[2,821]),o($Vn4,[2,822]),o($Vn4,[2,823]),o($Vn4,[2,824]),o($Vn4,[2,825]),o($Vn4,[2,826]),o($Vn4,[2,827]),o($Vn4,[2,828]),o($Vn4,[2,829]),{17:[1,928],27:$Vo5},{17:[1,929],27:$V06},{100:[1,930],163:$V16,229:$V26,256:$V36},o($VL4,$V46),o($Vz6,$V66,{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vz6,$V86,{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vz6,$V96,{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vz6,$Va6,{327:369,106:$Vo4,205:$Vq4,213:$Vu4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),{7:[1,931]},{7:$VV2,19:254,45:932,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vl4,$Vm4,{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,355:757,21:843,45:858,325:933,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,326:[1,934],327:369},o($VA6,$Ve6,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),o($VA6,$Vg6,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),o($Vm5,$Vh6,{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vm5,$Vi6,{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($Vm5,$Vj6,{327:369,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),{3:738,4:191,5:192,13:$Vk2,90:$V62,357:724,359:726,361:728,363:730,365:732,367:734,369:736},{7:$VV2,19:254,45:935,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,253:[1,936],327:369},{8:$Vo6,17:$VB6},o($VC6,$Vs6,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),{8:$Vx6,17:$VB6},{20:[1,938],106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,327:369},{7:$VV2,8:$Vy6,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:939,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:940,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:941,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vd2,[2,157]),o($Vq3,[2,175],{17:$VJ4}),{7:$Vm2,19:254,22:$VK4,23:944,45:205,46:209,76:248,77:$V$1,92:942,96:943,103:202,104:204,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($Vq3,[2,178],{17:$VJ4}),o($Vq3,[2,179],{169:155,199:159,103:202,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,45:301,160:309,152:310,316:311,121:312,123:313,138:316,92:945,7:$VV2,77:$V$1,106:$Vn2,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vq3,[2,180],{169:155,199:159,103:202,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,45:301,160:309,152:310,316:311,121:312,123:313,138:316,92:946,7:$VV2,77:$V$1,106:$Vn2,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vd2,$Vq5,{53:775,54:776,55:777,52:947,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($Vd2,[2,167]),o($Vd2,[2,69],{55:948,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($Vd2,[2,70]),o($Vd2,[2,73],{169:155,199:159,349:536,306:540,324:541,350:548,19:549,55:817,56:949,53:950,7:$VB4,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42}),{64:$VD6},{64:$VE6,66:[1,953]},{64:$VF6},o($VG6,[2,88]),{64:$VH6,66:[1,957],67:[1,955],69:[1,958]},{64:$VI6},{64:$VJ6,66:[1,962],67:[1,960],69:[1,963]},{64:$VK6},o($VL6,$VM6,{48:965,51:966,49:967,50:$VN6}),o($VO6,$VM6,{48:969,49:970,50:$VP6}),o($Vz5,$VQ6,{2:[1,973],22:[1,972]}),{22:[1,975],36:[1,974]},o($VO6,$VM6,{49:970,48:976,50:$VP6}),o($VC5,$VQ6),{36:[1,977]},o($VC5,$VA5,{34:791,33:978,35:$VD5}),o([50,75,81],$VA5,{34:791,38:980,33:981,22:[1,979],35:$VB5}),o($Vp5,[2,229]),o($Vp5,[2,230],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3}),o([2,8,22,35,50,63,64,65,66,67,68,69,70,75,81,115,177,194],[2,228]),o($Vp5,[2,232],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o([2,8,22,35,50,75,81,115,177,194],$VR6,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($VO6,$VM6,{49:970,48:982,50:$VP6}),o($Vp5,$VR6,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),{7:$V24,19:544,22:$Va,23:985,31:983,32:984,56:532,60:534,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,263:$VV1,294:545,306:540,307:542,324:541,329:543,345:530,346:531,347:533,348:535,349:536,350:537,351:538,352:539},{7:$VB4,19:549,31:986,56:547,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,306:540,324:541,345:530,347:533,349:536,350:548},o($VJ5,$VS6,{59:815,55:987,58:988,63:$VL5,64:$Vs5,65:$VM5,66:$VN5,67:$VO5,68:$VP5,69:$VQ5,70:$VR5}),o($VI5,[2,793]),{7:$V24,19:544,22:$VT6,56:989,60:990,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,294:545,306:540,307:542,324:541,329:543,349:536,350:537,351:538,352:539},o($VI5,[2,80],{55:817,53:992,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),{22:[1,993],64:$VD6},{22:[1,995],64:$VE6,66:[1,994]},{22:[1,996],64:$VF6},{22:[1,1000],64:$VH6,66:[1,998],67:[1,997],69:[1,999]},{22:[1,1001],64:$VI6},{22:[1,1005],64:$VJ6,66:[1,1003],67:[1,1002],69:[1,1004]},{22:[1,1006],64:$VK6},o($VU6,[2,76],{169:155,199:159,349:536,306:540,324:541,350:548,19:549,56:1007,7:$VB4,77:$V$1,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42}),o($VI5,[2,794],{55:948,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),{7:$VB4,19:549,56:949,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,306:540,324:541,349:536,350:548},o($VS5,[2,795]),o($VS5,[2,796]),o($VT5,[2,799]),o($VT5,[2,797]),o($VT5,[2,798]),{19:1008,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,263:$Vd5,294:691,296:1009},{19:1010,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{7:$VB4,19:549,31:983,56:547,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,306:540,324:541,345:530,347:533,349:536,350:548},o($VI5,$VS6,{55:948,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),{19:1008,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42},{2:$Vl2,7:$Vm2,19:254,22:$V04,23:512,45:205,46:209,76:248,77:$V$1,103:510,104:513,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,182:1011,183:[1,1012],199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$VV2,17:[1,1013],19:254,45:301,76:248,77:$V$1,92:509,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V$3,[2,630]),o($V$3,[2,631]),o($V$3,[2,632]),{22:[1,1015],27:[1,1014]},o($V54,[2,668]),o($V54,[2,669]),o($V54,[2,670]),o($V54,[2,666]),o($Vl4,$Vm4,{169:155,199:159,159:211,164:219,160:220,152:221,120:222,162:223,126:225,166:226,167:227,316:228,121:233,123:234,125:235,338:236,127:237,129:238,131:239,339:240,317:241,303:242,132:243,133:244,134:245,76:248,340:249,135:250,136:251,137:252,341:253,19:254,138:255,342:258,343:259,265:260,269:261,344:262,267:263,270:264,355:475,25:845,334:846,23:847,45:848,46:849,21:1016,325:1017,7:$Vm2,17:$Vb6,22:$V04,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1}),o($V54,[2,692]),{22:[1,1019],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,326:[1,1018],327:369,331:370},{106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,326:[1,1020],327:398},o($VU4,[2,703],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,213:$Vh3,220:$Vi3,237:$Vj3,244:$Vm3,245:$Vn3}),{8:[1,1021]},{8:$VV6,17:$VW6,22:$VX6},{2:$V15,8:$V25,24:1025},{2:$V15,8:$V25,24:1026},{2:$V15,8:$V25,17:$VY6,24:1027},o($VZ6,$V_6,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($V$6,[2,744],{327:398,17:[1,1029],106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),{22:$Va,23:1030,263:$VV1},{7:$Vm2,19:254,22:[1,1033],45:1031,46:1032,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V54,[2,708]),{7:$VV2,19:254,45:1034,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vl4,$Vm4,{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,355:757,45:858,325:1035,21:1036,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,326:[1,1037],327:369},{2:$V15,8:$V25,17:$V07,24:1038},{2:$V15,8:$V25,24:1040},o($V17,$V_6,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),{7:$VV2,19:254,45:1041,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vj5,[2,810]),{8:[1,1042]},o($Vk5,[2,812]),o($Vk5,[2,813]),o($V54,[2,738]),{2:$V35,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,227:$V55,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,327:369,333:1043},o($V54,[2,913]),o($Vn6,[2,929],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:1044,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vn6,[2,932],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),{22:[1,1046],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,227:$V27,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,327:369,331:370},{2:$V35,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,227:$V55,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,327:398,333:1047},{2:$V35,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,227:$V55,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3,327:346,333:1048},{2:$V35,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,227:$V55,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,253:$Vm6,327:369,333:1049},o($V54,[2,908]),o($V95,[2,921],{394:670,261:$VC4}),o($V95,[2,920],{394:670,261:$VC4}),{2:$V35,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,227:$V55,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,327:369,333:1050},o($V54,[2,906]),o($V54,[2,911]),{7:$Vm2,19:254,22:[1,1053],45:1051,46:1052,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($Vn6,[2,937],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:1054,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vn6,[2,925],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:1055,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vn6,[2,928],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($Vn6,[2,942],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,327:346,45:1056,7:$VV2,77:$V$1,106:$VV4,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,327:369,331:370},o($Vn6,[2,934],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($Vn6,[2,935],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:1057,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($V$3,[2,310]),{2:$V15,8:$V25,17:$V37,24:1058},{7:$Vm2,19:254,22:$V04,23:1062,45:1060,46:1061,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V54,[2,311]),o($Vn4,[2,324],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:761,139:1063,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($V54,[2,313]),{7:$VV2,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:1064,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vn4,[2,325],{17:[1,1065]}),{19:254,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,303:242,316:1066},{8:$V47,80:1069,81:$V57,83:1070,372:1067,374:1068},o($Vn4,$V47,{372:1072,80:1073,81:$V67}),o($V$6,$Vu6,{375:900,371:1075,240:$Vv6}),{22:[1,1077],36:[1,1076]},o($V$6,[2,846]),{8:$V47,80:1073,81:$V67,372:1067},{36:[1,1078]},o($Vw6,[2,274]),{2:$V15,8:$V25,17:$V37,24:1079},o($V77,[2,275]),o($V77,[2,277]),{22:[1,1081],158:1080,216:$V87,217:$V97,219:$Va7,223:$Vb7,224:$Vc7,230:$Vd7,234:$Ve7,250:$Vf7,251:$Vg7,254:$Vh7,255:$Vi7,260:$Vj7},{2:$V15,8:$V25,24:1095,158:1094,216:$V87,217:$V97,219:$Va7,223:$Vb7,224:$Vc7,230:$Vd7,234:$Ve7,250:$Vf7,251:$Vg7,254:$Vh7,255:$Vi7,260:$Vj7},{2:$V15,8:$V25,24:1097,158:1096,216:$V87,217:$V97,219:$Va7,223:$Vb7,224:$Vc7,230:$Vd7,234:$Ve7,250:$Vf7,251:$Vg7,254:$Vh7,255:$Vi7,260:$Vj7},o($V54,[2,286]),{2:$V15,8:$V25,24:1099,158:1098,216:$V87,217:$V97,219:$Va7,223:$Vb7,224:$Vc7,230:$Vd7,234:$Ve7,250:$Vf7,251:$Vg7,254:$Vh7,255:$Vi7,260:$Vj7},o($V54,[2,289]),{2:$V15,8:$V25,24:1100},o($Ve4,[2,249]),{8:$Vk7,17:$Vp6,22:[1,1102]},{2:$V15,8:$V25,17:$Vq6,24:1103},{2:$V15,8:$V25,24:1104},o($Ve4,[2,262]),{8:$Vl7,17:$Vp6,22:[1,1106]},{2:$V15,8:$V25,17:$Vq6,24:1107},{2:$V15,8:$V25,24:1108},{8:$Vm7,22:[1,1110],106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3,327:369,331:370},{2:$V15,8:$V25,24:1111},{2:$V15,8:$V25,24:1112,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3,327:398},o($V$3,[2,776]),{177:$Vj4,194:[2,367]},o($Vn4,[2,815]),{7:$VV2,19:254,45:301,76:248,77:$V$1,92:1113,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{2:$Vl2,7:$VV2,19:254,45:301,76:248,77:$V$1,103:510,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,182:1114,183:$VF2,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{27:[1,1115]},o($Vl4,$Vm4,{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,355:757,45:858,21:1016,325:1116,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,326:[1,1117],327:369},{8:$VV6,17:$V07},{7:$VV2,19:254,45:1118,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,227:$V27,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,327:369},{7:$VV2,19:254,45:1119,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:1120,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{158:1080,216:$V87,217:$V97,219:$Va7,223:$Vb7,224:$Vc7,230:$Vd7,234:$Ve7,250:$Vf7,251:$Vg7,254:$Vh7,255:$Vi7,260:$Vj7},{8:$Vk7,17:$VB6},{8:$Vl7,17:$VB6},{8:$Vm7,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3,327:369},{17:$Vn7,22:$V$5,27:$Vo7},{27:[2,351]},{20:$V_3,27:[2,354]},o($Vq3,[2,181],{17:$VJ4}),o($Vq3,[2,182],{17:$VJ4}),o($Vd2,[2,166]),{7:$VB4,19:549,56:1122,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,306:540,324:541,349:536,350:548},o($VU6,$Vp7,{57:1123,71:$Vq7}),o($Vd2,[2,74],{55:948,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($VG6,[2,84]),o($VG6,[2,85]),{64:$Vr7},o($VG6,[2,87]),{64:$Vs7},o($VG6,[2,90]),{64:$Vt7},{64:$Vu7},o($VG6,[2,93]),{64:$Vv7},o($VG6,[2,95]),{64:$Vw7},{64:$Vx7},o($VG6,[2,98]),o($Vy7,$Vz7,{79:1132,83:1133,80:1134,81:$V57}),o($VA7,$Vz7,{79:1135,80:1136,81:$V67}),o($VL6,$VB7,{2:[1,1138],22:[1,1137]}),{7:$Vm2,19:254,22:[1,1139],45:1141,46:1140,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VA7,$Vz7,{80:1136,79:1142,81:$V67}),o($VO6,$VB7),{7:$VV2,19:254,45:1143,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VO6,$VM6,{49:970,48:1144,50:$VP6}),o($VC7,$VM6,{49:970,51:1145,48:1146,50:$VN6}),{7:$Vm2,19:254,22:[1,1148],37:1149,39:1147,45:1151,46:1150,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VC5,[2,39]),o($VA7,$Vz7,{80:1136,79:1152,81:$V67}),{7:$VV2,19:254,37:1153,45:1154,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VO6,$VM6,{49:970,48:1155,50:$VP6}),o($VC5,$VA5,{34:791,33:1156,35:$VD5}),o($VO6,$VM6,{49:970,48:1157,50:$VP6}),o($VC7,$VM6,{49:970,51:1158,48:1159,50:$VN6}),o($VA7,$Vz7,{80:1136,79:1160,81:$V67}),o($VH5,[2,28]),o($VG5,[2,31],{17:[1,1161]}),o($VG5,[2,33]),o($VG5,[2,30]),{7:$V24,19:544,22:$VT6,56:1162,60:990,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$VA3,294:545,306:540,307:542,324:541,329:543,349:536,350:537,351:538,352:539},o($VI5,[2,82],{55:817,53:1163,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($VD7,$Vp7,{57:1123,61:1164,71:$VE7}),o($VU6,$Vp7,{57:1166,71:$Vq7}),o($VU6,$Vp7,{57:1167,71:$Vq7}),o($VI5,[2,81],{55:948,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($VF7,[2,99]),{22:[1,1168],64:$Vr7},{2:[1,1170],64:[1,1169]},o($VF7,[2,102]),{22:[1,1171],64:$Vs7},{22:[1,1172],64:$Vt7},{22:[1,1173],64:$Vu7},{2:[1,1175],64:[1,1174]},o($VF7,[2,107]),{22:[1,1176],64:$Vv7},{22:[1,1177],64:$Vw7},{22:[1,1178],64:$Vx7},{2:[1,1180],64:[1,1179]},o($VF7,[2,112]),o($VU6,$Vp7,{57:1181,71:$Vq7}),o($VU5,[2,559]),o($VV5,[2,562]),o($VV5,[2,561]),{17:[1,1182],27:$VG7},{17:[1,1183]},{7:$VV2,19:254,45:301,76:248,77:$V$1,92:768,103:202,106:$Vn2,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:575,45:1184,46:1186,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$VA3,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,293:1185,294:576,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V54,[2,667]),{8:[1,1187]},{8:$VH7,17:$VW6,22:$VX6},{7:$Vm2,19:254,22:[1,1191],45:1189,46:1190,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V54,[2,702]),{7:$VV2,19:254,45:1192,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V$3,[2,642]),o($V$3,[2,643]),{7:$Vm2,19:254,22:$V04,23:1195,45:1193,46:1194,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{17:$VI7},o($V54,[2,889]),o($V54,[2,890]),o($V54,[2,891]),o($V$6,[2,752],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:858,325:1197,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),{7:$VV2,19:254,45:858,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,325:1198,338:236,340:249,342:258,343:259,344:262},o($V$6,[2,753],{17:[1,1199]}),o([2,8,17,20,22,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,194,200,201,202,203,212,214,215,225,226,227,239,243,247,249,253,261,326],$VJ7,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,244:$VI3,245:$VJ3}),o($VK7,[2,706],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,244:$Vm3,245:$Vn3}),o($Vc6,[2,707],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,244:$Vm3,245:$Vn3}),o($VK7,[2,705],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),{2:$V15,8:$V25,17:$V07,24:1200},{2:$V15,8:$V25,24:1201},{7:$VV2,19:254,45:1202,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V54,[2,696]),{7:$VV2,19:254,45:1203,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V54,[2,697]),o($VK7,[2,704],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),o($Vj5,[2,811]),o($V54,[2,912]),o($Vn6,[2,930],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($V$3,[2,902]),o($V54,[2,904]),o($V54,[2,909]),o($V54,[2,910]),o($V54,[2,907]),o($V54,[2,905]),o([22,226,227,261],$VL7,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($Vn6,[2,927],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($Vn6,[2,939],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,327:346,45:1204,7:$VV2,77:$V$1,106:$VV4,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vn6,[2,938],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($Vn6,[2,926],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($Vn6,[2,941],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($Vn6,[2,936],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($V54,[2,312]),{7:$VV2,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:1205,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vr6,$VM7,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($Vn4,[2,317],{327:398,17:[1,1206],106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($Vn4,[2,320],{17:[1,1207]}),o($Vn4,[2,323],{17:$VB6}),o($Vn4,[2,318],{17:$VB6}),{7:$VV2,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:1208,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($V54,[2,598],{206:[1,1209]}),{8:[1,1210]},{2:$V15,8:$V25,24:1211},{8:$VN7,22:[1,1213],243:$VO7,247:$VP7,376:1212,377:1214,378:1215,379:1216},o($Vn4,[2,853]),{22:[1,1220],36:[1,1219]},{2:$V15,8:$V25,24:1221},o($Vn4,$VN7,{376:1212,378:1215,379:1222,243:$VO7,247:$VP7}),{36:[1,1223]},o($Vn4,$V47,{80:1073,372:1224,81:$V67}),{7:$Vm2,17:$Vb6,19:254,22:[1,1226],23:1228,45:848,46:849,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,325:1225,334:1227,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($V$6,[2,848]),{7:$VV2,19:254,45:858,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,325:1229,338:236,340:249,342:258,343:259,344:262},o($V77,[2,276]),{8:[1,1230]},{2:$V15,8:$V25,24:1231},o($Vn4,[2,608]),o($Vn4,[2,609]),o($Vn4,$VQ7,{321:1232,7:$VR7}),o($Vn4,[2,622],{322:1234,7:[1,1235]}),o($Vn4,[2,612]),o($Vn4,[2,613]),o($Vn4,[2,614]),o($Vn4,[2,615]),o($Vn4,[2,616]),o($Vn4,[2,617]),o($Vn4,[2,618]),o($Vn4,$VQ7,{321:1236,7:$VR7}),{2:$V15,8:$V25,24:1237},o($V54,[2,291]),{2:$V15,8:$V25,24:1238},o($V54,[2,285]),{2:$V15,8:$V25,24:1239},o($V54,[2,288]),o($V54,[2,293]),o($Ve4,[2,250]),{2:$V15,8:$V25,17:$V37,24:1240},o($V54,[2,251]),o($V54,[2,253]),o($Ve4,[2,264]),{2:$V15,8:$V25,17:$V37,24:1241},o($V54,[2,265]),o($V54,[2,267]),o($Ve4,[2,268]),{2:$V15,8:$V25,24:1242},o($V54,[2,270]),o($V54,[2,272]),{17:$VJ4,27:$Vo7},{27:$VG7},{7:$VV2,19:254,45:1243,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{8:$VH7,17:$V07},{7:$VV2,19:254,45:1244,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o([2,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,95,115,117,177,194,200,201,202,203,212,214,215,225,226,227,239,243,247,249,253,261,326],$VJ7,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,244:$Vm3,245:$Vn3}),o($Vn6,$VL7,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($VC6,$VM7,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),{7:$Vm2,19:254,22:$V04,23:512,45:205,46:209,76:248,77:$V$1,103:510,104:513,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VU6,$Vp7,{57:1245,71:$Vq7}),o($VS7,[2,71]),{7:$VV2,19:254,45:1246,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VG6,[2,86]),o($VG6,[2,89]),o($VG6,[2,91]),o($VG6,[2,92]),o($VG6,[2,94]),o($VG6,[2,96]),o($VG6,[2,97]),o($V63,$VT7,{73:1247,78:1248,74:1249,75:[1,1250]}),o($VU7,$VT7,{73:1251,74:1252,75:$VV7}),o($Vy7,$VW7,{2:[1,1255],22:[1,1254]}),o($VU7,$VT7,{74:1252,73:1256,75:$VV7}),o($VA7,$VW7),o($VA7,$Vz7,{80:1136,79:1257,81:$V67}),{22:[1,1258],75:$Vz7,79:1260,80:1136,81:$V57,83:1259},o($VO6,[2,66],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3}),o($VO6,[2,67],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o([2,8,22,75,81,115,177,194],$VX7,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($VU7,$VT7,{74:1252,73:1261,75:$VV7}),o($VO6,$VX7,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($VA7,$Vz7,{80:1136,79:1262,81:$V67}),o($VA7,$Vz7,{80:1136,79:1263,81:$V67}),{75:$Vz7,79:1265,80:1136,81:$V57,83:1264},o($VC5,[2,37]),o($VC5,[2,38],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,327:346,45:1266,7:$VV2,17:[1,1267],77:$V$1,106:$VV4,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o([2,8,22,50,75,81,115,177,194],$VY7,{17:[1,1268]}),o($VC5,[2,53],{327:398,17:[1,1269],106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($VZ7,$V_7,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($VU7,$VT7,{74:1252,73:1270,75:$VV7}),o($VC5,$VY7,{17:$V$7}),o($V08,$V_7,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($VA7,$Vz7,{80:1136,79:1272,81:$V67}),o($VO6,$VM6,{49:970,48:1273,50:$VP6}),o($VA7,$Vz7,{80:1136,79:1274,81:$V67}),o($VA7,$Vz7,{80:1136,79:1275,81:$V67}),{75:$Vz7,79:1277,80:1136,81:$V57,83:1276},o($VU7,$VT7,{73:1247,74:1252,75:$VV7}),{7:$VB4,19:549,28:1278,31:528,56:547,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,306:540,324:541,345:530,347:533,349:536,350:548},o($VD7,$Vp7,{61:1164,57:1245,71:$VE7}),o($VI5,[2,83],{55:948,63:$Vr5,64:$Vs5,65:$Vt5,66:$Vu5,67:$Vv5,68:$Vw5,69:$Vx5,70:$Vy5}),o($VU6,[2,78]),{7:$Vm2,19:254,22:[1,1281],45:1279,46:1280,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VU6,[2,77]),o($VU6,[2,79]),o($VF7,[2,101]),o($VF7,[2,100]),o($VF7,[2,113]),o($VF7,[2,104]),o($VF7,[2,105]),o($VF7,[2,106]),o($VF7,[2,103]),o($VF7,[2,114]),o($VF7,[2,109]),o($VF7,[2,110]),o($VF7,[2,111]),o($VF7,[2,108]),o($VF7,[2,115]),o($VU6,[2,75]),{7:$Vm2,19:254,22:$VK4,23:210,45:205,46:209,76:248,77:$V$1,92:1283,96:1282,103:202,104:204,106:$Vn2,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{2:$VQ4,22:$Va,23:1284,263:$VV1},o($VZ4,$V18,{327:369,331:370}),o($V54,[2,671]),o($V$4,[2,672],{327:398}),o($V$3,[2,640]),o($V$3,[2,641]),o($VR4,$V28,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,213:$Vz3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,244:$VI3,245:$VJ3}),o($VT4,[2,700],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,213:$VU3,220:$VW3,233:$VX3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VU4,[2,701],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,213:$Vh3,220:$Vi3,237:$Vj3,244:$Vm3,245:$Vn3}),o($VT4,[2,699],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($VZ6,$V38,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($V$6,[2,745],{327:398,17:[1,1285],106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($V$6,[2,748],{17:[1,1286]}),{7:$VV2,19:254,45:858,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,325:1287,338:236,340:249,342:258,343:259,344:262},o($V$6,[2,751],{17:$V07}),o($V$6,[2,746],{17:$V07}),{7:$VV2,19:254,45:858,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,325:1288,338:236,340:249,342:258,343:259,344:262},o($V54,[2,694]),o($V54,[2,695]),o($VT4,[2,698],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($V17,$V38,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($Vn6,[2,940],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($Vn4,[2,322],{17:$VB6}),{7:$VV2,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:1289,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:761,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,139:1290,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($Vn4,[2,326],{17:$VB6}),{19:254,77:$V$1,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,214:$V42,303:688},o($V$3,[2,840]),o($V54,[2,842]),o($Vn4,[2,852]),o($Vn4,$VN7,{378:1215,379:1222,376:1291,243:$VO7,247:$VP7}),o($Vn4,[2,855]),o($Vn4,[2,857]),{22:[1,1292],215:[1,1293],383:[1,1294]},o($V48,[2,874]),o($V48,[2,875]),{7:$Vm2,19:254,22:[1,1299],23:1302,45:1300,46:1301,76:248,77:$V$1,82:1295,84:1296,85:1297,86:1298,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VA7,[2,133]),o($V54,[2,841]),{215:[1,1303],383:[1,1304]},{7:$VV2,19:254,45:1306,76:248,77:$V$1,82:1305,85:1297,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{2:$V15,8:$V25,24:1307},o($Vt6,$V58,{17:$VW6,22:[1,1308]}),o($V$6,[2,849],{327:346,17:$V_1,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3}),o($V$6,[2,850]),{17:$VY6},o($V$6,$V58,{17:$V07}),o($V$3,[2,282]),o($V54,[2,292]),o($Vn4,[2,610]),{257:[1,1309]},o($Vn4,[2,611]),{257:[1,1310]},o($Vn4,[2,619]),o($V54,[2,290]),o($V54,[2,284]),o($V54,[2,287]),o($V54,[2,252]),o($V54,[2,266]),o($V54,[2,271]),o($Vm5,$V18,{327:369}),o($Vl5,$V28,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,213:$Vu4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,244:$Vm3,245:$Vn3}),o($VS7,[2,72]),o($VU6,$V68,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($VU7,[2,188]),o($VU7,[2,193]),o($V63,$V78,{2:[1,1312],22:[1,1311]}),{22:$V88,76:1314,77:$V98,206:$VI2,257:$VR2,258:$VS2,342:258,343:259},o($VU7,[2,192]),o($VU7,$V78),{76:1314,77:$V98,206:$VI2,257:$VR2,258:$VS2,342:258,343:259},o($VU7,$VT7,{74:1252,73:1316,75:$VV7}),{22:[1,1317],75:$Va8,78:1318},o($VU7,[2,191]),o($VU7,$VT7,{74:1252,73:1320,75:$VV7}),o($VA7,$Vz7,{80:1136,79:1321,81:$V67}),o($VU7,$VT7,{74:1252,73:1322,75:$VV7}),{75:$Va8,78:1323},o($VU7,[2,190]),o($VU7,$VT7,{74:1252,73:1324,75:$VV7}),o($VU7,$VT7,{74:1252,73:1325,75:$VV7}),o($VU7,$VT7,{74:1252,73:1326,75:$VV7}),{75:$Va8,78:1327},o($VC5,[2,54],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),{7:$VV2,19:254,37:1328,45:1154,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{7:$Vm2,19:254,22:$V04,23:1332,45:1330,46:1331,47:1329,76:248,77:$V$1,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},{7:$VV2,19:254,37:1333,45:1154,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VU7,[2,189]),{7:$VV2,19:254,45:1334,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},o($VU7,$VT7,{74:1252,73:1335,75:$VV7}),o($VA7,$Vz7,{80:1136,79:1336,81:$V67}),o($VU7,$VT7,{74:1252,73:1337,75:$VV7}),o($VU7,$VT7,{74:1252,73:1338,75:$VV7}),o($VU7,$VT7,{74:1252,73:1339,75:$VV7}),{75:$Va8,78:1340},o($VG5,[2,32],{17:$VX5}),o($VD7,$V68,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($VU6,[2,120],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($VU6,[2,121],{327:346,106:$VV4,187:$Vd3,207:$Ve3,208:$Vf3,212:$Vg3,213:$Vh3,220:$Vi3,237:$Vj3,238:$VY4,239:$Vl3,244:$Vm3,245:$Vn3}),{27:[2,352]},{17:$Vn7,22:$V$5},{27:[2,355]},{7:$VV2,19:254,45:858,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,325:1341,338:236,340:249,342:258,343:259,344:262},{7:$VV2,19:254,45:858,76:248,77:$V$1,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,325:1342,338:236,340:249,342:258,343:259,344:262},o($V$6,[2,750],{17:$V07}),o($V$6,[2,754],{17:$V07}),o($Vn4,[2,319],{17:$VB6}),o($Vn4,[2,321],{17:$VB6}),o($Vn4,[2,854]),o($Vn4,[2,860]),o($Vb8,$Vc8,{380:1343}),o($Vb8,$Vc8,{380:1344}),o([2,8,22,75,115,177,194,243,247],$Vd8,{17:[1,1345]}),o($VA7,[2,132]),o($Ve8,[2,134]),o($VA7,[2,136]),o([2,8,63,64,65,66,67,68,69,70,75,88,89,115,177,194],$V_1,{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,327:346,45:1306,85:1346,7:$VV2,77:$V$1,106:$VV4,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,187:$Vd3,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,207:$Ve3,208:$Vf3,211:$V03,212:$Vg3,213:$Vh3,214:$V42,218:$V13,220:$Vi3,225:$V23,228:$V33,229:$VN2,237:$Vj3,238:$Vk3,239:$Vl3,244:$Vm3,245:$Vn3,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o([2,8,17,22,75,115,177,194,243,247],$Vf8,{327:369,331:370,87:1347,88:$Vg8,89:$Vh8,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($Vi8,$Vf8,{327:398,87:1350,88:$Vg8,89:$Vh8,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($Vi8,$Vf8,{87:1351,88:$Vg8,89:$Vh8}),o($Vj8,$Vc8,{380:1352}),o($Vj8,$Vc8,{380:1353}),o([2,8,63,64,65,66,67,68,69,70,75,115,177,194,243,247],$Vd8,{17:$Vk8}),o([2,8,17,63,64,65,66,67,68,69,70,75,115,177,194,243,247],$Vf8,{327:369,87:1347,88:$Vg8,89:$Vh8,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($V54,[2,843]),o($Vn4,$V47,{80:1073,372:1355,17:$VI7,81:$V67}),{8:[1,1356]},{8:[1,1357],17:[1,1358]},o($VU7,[2,198]),{22:[1,1359]},o($VU7,[2,128]),o($Vl8,[2,124],{17:[1,1360]}),o($Vl8,[2,126],{17:[1,1361]}),o($VU7,[2,197]),o($VU7,$VT7,{74:1252,73:1362,75:$VV7}),o($VU7,[2,212]),{22:$V88},o($VU7,[2,196]),o($VU7,$VT7,{74:1252,73:1363,75:$VV7}),o($VU7,[2,210]),o($VU7,[2,211]),o($VU7,[2,195]),o($VU7,[2,207]),o($VU7,[2,208]),o($VU7,[2,209]),o($VC5,[2,55],{17:$V$7}),o($VC5,[2,57],{17:[1,1364]}),o($VZ7,$Vm8,{327:369,331:370,106:$Vt3,187:$Vu3,205:$Vv3,207:$Vw3,208:$Vx3,212:$Vy3,213:$Vz3,215:$VB3,220:$VC3,233:$VD3,236:$VE3,237:$VF3,238:$VG3,239:$VH3,244:$VI3,245:$VJ3}),o($V08,[2,60],{327:398,106:$VO3,187:$VP3,205:$VQ3,207:$VR3,208:$VS3,212:$VT3,213:$VU3,215:$VV3,220:$VW3,233:$VX3,237:$Vj3,238:$VY3,239:$VZ3,244:$Vm3,245:$Vn3}),o($V08,[2,62],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:1365,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($VC5,[2,56],{17:$V$7}),o($V08,$Vm8,{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($VU7,[2,194]),o($VU7,$VT7,{74:1252,73:1366,75:$VV7}),o($VU7,[2,203]),o($VU7,[2,204]),o($VU7,[2,205]),o($VU7,[2,206]),o($V$6,[2,747],{17:$V07}),o($V$6,[2,749],{17:$V07}),o($Vn8,$Vo8,{381:1367,384:1368,391:1369,221:$Vp8,257:$Vq8,383:$Vr8}),o($Vn8,$Vo8,{391:1369,381:1373,384:1374,221:$Vp8,257:$Vq8,383:$Vr8}),{7:$Vm2,19:254,22:$V04,23:1302,45:1300,46:1301,76:248,77:$V$1,85:1375,86:1376,120:222,121:233,123:234,125:235,126:225,127:237,129:238,131:239,132:243,133:244,134:245,135:250,136:251,137:252,138:255,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$Vw2,150:$Vx2,151:$Vy2,152:221,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VD2,159:211,160:220,162:223,163:$VE2,164:219,166:226,167:227,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$VG2,205:$VH2,206:$VI2,211:$VJ2,214:$V42,218:$VK2,225:$VL2,228:$VM2,229:$VN2,238:$VO2,249:$VP2,256:$VQ2,257:$VR2,258:$VS2,263:$VV1,265:260,267:263,269:261,270:264,303:242,316:228,317:241,338:236,339:240,340:249,341:253,342:258,343:259,344:262},o($VA7,[2,137]),o($Ve8,[2,141]),o($Ve8,[2,145]),o($Ve8,[2,146]),o($Vi8,[2,142]),o($Vi8,[2,143]),o($Vs8,$Vo8,{381:1377,391:1378,221:$Vt8,257:$Vq8,383:$Vr8}),o($Vs8,$Vo8,{391:1378,381:1380,221:$Vt8,257:$Vq8,383:$Vr8}),{7:$VV2,19:254,45:1306,76:248,77:$V$1,85:1375,120:222,121:312,123:313,125:235,132:243,133:244,134:245,138:316,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,152:310,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,159:211,160:309,162:223,163:$VE2,169:155,199:159,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2,265:260,269:261,303:242,316:311,338:236,340:249,342:258,343:259,344:262},{2:$V15,8:$V25,24:1381},o($Vn4,[2,621]),o($Vn4,[2,623]),{257:[1,1382]},o($VU7,[2,202]),{76:1383,206:$VI2,257:$VR2,258:$VS2,342:258,343:259},{77:[1,1384]},o($VU7,[2,201]),o($VU7,[2,200]),o($VC5,[2,58],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,45:1154,37:1385,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($V08,[2,61],{327:369,106:$Vo4,187:$Vp4,205:$Vq4,207:$Vr4,208:$Vs4,212:$Vt4,213:$Vu4,215:$Vv4,220:$Vw4,233:$Vx4,236:$Vy4,237:$Vj3,238:$Vz4,239:$VA4,244:$Vm3,245:$Vn3}),o($VU7,[2,199]),o([8,22],$Vu8,{382:1386,385:1387,212:[1,1388]}),o($Vn4,$Vu8,{382:1389,212:$Vv8}),{22:[1,1392],241:$Vw8},{22:[1,1394],246:$Vx8},o($Vy8,[2,887]),o($Vy8,[2,888]),{8:$Vu8,22:[1,1395],212:$Vv8,382:1396},o($Vn4,[2,865]),o($Ve8,[2,135]),o($VA7,[2,138],{17:[1,1397]}),o($Vn4,$Vu8,{382:1398,212:$Vv8}),{241:$Vw8},{246:$Vx8},o($Vn4,$Vu8,{382:1396,212:$Vv8}),o($V54,[2,844]),{8:[1,1399]},o($Vl8,[2,125]),o($Vl8,[2,127]),o($VC5,[2,59],{17:$V$7}),{8:$Vz8,22:[1,1400]},o($Vn4,[2,863]),{22:[1,1403],221:[1,1401],257:$Vq8,383:$Vr8,391:1402},o($Vn4,[2,862]),{221:[1,1404],257:$Vq8,383:$Vr8,391:1405},o($VA8,[2,877]),o($Vs8,[2,879]),o($VA8,[2,878]),o($Vs8,[2,880]),o($Vn4,[2,864]),o($Vn4,[2,859]),o($VA7,[2,139],{169:155,199:159,159:211,120:222,162:223,125:235,338:236,303:242,132:243,133:244,134:245,76:248,340:249,19:254,342:258,343:259,265:260,269:261,344:262,160:309,152:310,316:311,121:312,123:313,138:316,85:1297,45:1306,82:1406,7:$VV2,77:$V$1,141:$Vo2,142:$Vp2,143:$Vq2,144:$Vr2,145:$Vs2,146:$Vt2,147:$Vu2,148:$Vv2,149:$VW2,150:$VX2,151:$VY2,153:$Vz2,154:$VA2,155:$VB2,156:$VC2,157:$VZ2,163:$VE2,200:$V02,201:$V12,202:$V22,203:$V32,204:$V_2,205:$V$2,206:$VI2,211:$V03,214:$V42,218:$V13,225:$V23,228:$V33,229:$VN2,238:$V43,249:$V53,256:$VQ2,257:$VR2,258:$VS2}),o($Vn4,$Vz8),o($Vn4,[2,624]),o($Vn4,[2,861]),{22:[1,1408],246:$VB8},{22:[1,1410],231:$VC8},o($Vn4,[2,884]),{246:$VB8},{231:$VC8},o($VA7,[2,140],{17:$Vk8}),o($VD8,[2,882]),o($Vn4,[2,885]),o($VD8,[2,883]),o($Vn4,[2,886])], +defaultActions: {9:[2,377],10:[2,378],11:[2,379],12:[2,380],13:[2,381],14:[2,382],15:[2,383],16:[2,384],17:[2,385],18:[2,386],19:[2,387],20:[2,388],21:[2,389],22:[2,390],23:[2,391],24:[2,392],25:[2,393],26:[2,394],27:[2,395],28:[2,396],29:[2,397],30:[2,398],31:[2,399],32:[2,400],33:[2,401],34:[2,402],35:[2,403],36:[2,404],37:[2,405],38:[2,406],39:[2,407],40:[2,408],41:[2,409],42:[2,410],43:[2,411],44:[2,412],45:[2,413],46:[2,414],47:[2,415],48:[2,416],49:[2,417],50:[2,418],51:[2,419],52:[2,420],53:[2,421],54:[2,422],55:[2,423],56:[2,424],57:[2,425],58:[2,426],59:[2,427],60:[2,428],61:[2,429],62:[2,430],63:[2,431],64:[2,432],65:[2,433],66:[2,434],67:[2,435],68:[2,436],69:[2,437],70:[2,438],71:[2,439],72:[2,440],73:[2,441],74:[2,442],75:[2,443],76:[2,444],77:[2,445],78:[2,446],79:[2,447],80:[2,448],81:[2,449],82:[2,450],83:[2,451],84:[2,452],85:[2,453],86:[2,454],87:[2,455],88:[2,456],89:[2,457],90:[2,458],91:[2,459],92:[2,460],93:[2,461],94:[2,462],95:[2,463],96:[2,464],97:[2,465],98:[2,466],99:[2,467],100:[2,468],101:[2,469],102:[2,470],103:[2,471],104:[2,472],105:[2,473],106:[2,474],107:[2,475],108:[2,476],109:[2,477],110:[2,478],111:[2,479],112:[2,480],113:[2,481],114:[2,482],115:[2,483],116:[2,484],133:[2,361],135:[2,362],229:[2,278],230:[2,279],231:[2,280],232:[2,281],265:[2,254],266:[2,255],267:[2,256],268:[2,257],269:[2,258],270:[2,259],271:[2,260],272:[2,261],565:[2,350],943:[2,351],1114:[2,347],1282:[2,352],1284:[2,355]}, +parseError: function parseError (str, hash) { + if (hash.recoverable) { + this.trace(str); + } else { + var error = new Error(str); + error.hash = hash; + throw error; + } +}, +/** + * @param {string} input + * + * @return {AutocompleteParseResult} + */ +parse: function parse (input) { + var self = this, + stack = [0], + tstack = [], // token stack + vstack = [null], // semantic value stack + lstack = [], // location stack + table = this.table, + yytext = '', + yylineno = 0, + yyleng = 0, + recovering = 0, + TERROR = 2, + EOF = 1; + + var args = lstack.slice.call(arguments, 1); + + //this.reductionCount = this.shiftCount = 0; + + var lexer = Object.create(this.lexer); + var sharedState = { yy: {} }; + // copy state + for (var k in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k)) { + sharedState.yy[k] = this.yy[k]; + } + } + + lexer.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer; + sharedState.yy.parser = this; + if (typeof lexer.yylloc == 'undefined') { + lexer.yylloc = {}; + } + var yyloc = lexer.yylloc; + lstack.push(yyloc); + + var ranges = lexer.options && lexer.options.ranges; + + if (typeof sharedState.yy.parseError === 'function') { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + + function popStack (n) { + stack.length = stack.length - 2 * n; + vstack.length = vstack.length - n; + lstack.length = lstack.length - n; + } + +_token_stack: + var lex = function () { + var token; + token = lexer.lex() || EOF; + // if token isn't its numeric value, convert + if (typeof token !== 'number') { + token = self.symbols_[token] || token; + } + return token; + } + + var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected; + while (true) { + // retreive state number from top of stack + state = stack[stack.length - 1]; + + // use default actions if available + if (this.defaultActions[state]) { + action = this.defaultActions[state]; + } else { + if (symbol === null || typeof symbol == 'undefined') { + symbol = lex(); + } + // read action for current state and first input + action = table[state] && table[state][symbol]; + } + +_handle_error: + // handle parse error + if (typeof action === 'undefined' || !action.length || !action[0]) { + var error_rule_depth; + var errStr = ''; + + // Return the rule stack depth where the nearest error rule can be found. + // Return FALSE when no error recovery rule was found. + function locateNearestErrorRecoveryRule(state) { + var stack_probe = stack.length - 1; + var depth = 0; + + // try to recover from error + for(;;) { + // check for error recovery rule in this state + if ((TERROR.toString()) in table[state]) { + return depth; + } + if (state === 0 || stack_probe < 2) { + return false; // No suitable error recovery rule available. + } + stack_probe -= 2; // popStack(1): [symbol, action] + state = stack[stack_probe]; + ++depth; + } + } + + if (!recovering) { + // first see if there's any chance at hitting an error recovery rule: + error_rule_depth = locateNearestErrorRecoveryRule(state); + + // Report error + expected = []; + for (p in table[state]) { + if (this.terminals_[p] && p > TERROR) { + expected.push("'"+this.terminals_[p]+"'"); + } + } + if (lexer.showPosition) { + errStr = 'Parse error on line '+(yylineno+1)+":\n"+lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + (this.terminals_[symbol] || symbol)+ "'"; + } else { + errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " + + (symbol == EOF ? "end of input" : + ("'"+(this.terminals_[symbol] || symbol)+"'")); + } + this.parseError(errStr, { + text: lexer.match, + token: this.terminals_[symbol] || symbol, + line: lexer.yylineno, + loc: lexer.yylloc, + ruleId: stack.slice(stack.length - 2, stack.length).join('_'), + expected: expected, + recoverable: (error_rule_depth !== false) + }); + } else if (preErrorSymbol !== EOF) { + error_rule_depth = locateNearestErrorRecoveryRule(state); + } + + // just recovered from another error + if (recovering == 3) { + if (symbol === EOF || preErrorSymbol === EOF) { + throw new Error(errStr || 'Parsing halted while starting to recover from another error.'); + } + + // discard current lookahead and grab another + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + symbol = lex(); + } + + // try to recover from error + if (error_rule_depth === false) { + throw new Error(errStr || 'Parsing halted. No suitable error recovery rule available.'); + } + popStack(error_rule_depth); + + preErrorSymbol = (symbol == TERROR ? null : symbol); // save the lookahead token + symbol = TERROR; // insert generic error symbol as new lookahead + state = stack[stack.length-1]; + action = table[state] && table[state][TERROR]; + recovering = 3; // allow 3 real symbols to be shifted before reporting a new error + } + + // this shouldn't happen, unless resolve defaults are off + if (action[0] instanceof Array && action.length > 1) { + throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol); + } + + switch (action[0]) { + case 1: // shift + //this.shiftCount++; + + stack.push(symbol); + vstack.push(lexer.yytext); + lstack.push(lexer.yylloc); + stack.push(action[1]); // push state + symbol = null; + if (!preErrorSymbol) { // normal execution/no error + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + if (recovering > 0) { + recovering--; + } + } else { + // error just occurred, resume old lookahead f/ before error + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + + case 2: + // reduce + //this.reductionCount++; + + len = this.productions_[action[1]][1]; + + // perform semantic action + yyval.$ = vstack[vstack.length-len]; // default to $$ = $1 + // default location, uses first token for firsts, last for lasts + yyval._$ = { + first_line: lstack[lstack.length-(len||1)].first_line, + last_line: lstack[lstack.length-1].last_line, + first_column: lstack[lstack.length-(len||1)].first_column, + last_column: lstack[lstack.length-1].last_column + }; + if (ranges) { + yyval._$.range = [lstack[lstack.length-(len||1)].range[0], lstack[lstack.length-1].range[1]]; + } + r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args)); + + if (typeof r !== 'undefined') { + return r; + } + + // pop off stack + if (len) { + stack = stack.slice(0,-1*len*2); + vstack = vstack.slice(0, -1*len); + lstack = lstack.slice(0, -1*len); + } + + stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) + vstack.push(yyval.$); + lstack.push(yyval._$); + // goto new state = table[STATE][NONTERMINAL] + newState = table[stack[stack.length-2]][stack[stack.length-1]]; + stack.push(newState); + break; + + case 3: + // accept + return true; + } + + } + + return true; +}}; + + +SqlParseSupport.initSqlParser(parser);/* generated by jison-lex 0.3.4 */ +var lexer = (function(){ +var lexer = ({ + +EOF:1, + +parseError:function parseError(str, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str, hash); + } else { + throw new Error(str); + } + }, + +// resets the lexer, sets new input +setInput:function (input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ''; + this.conditionStack = ['INITIAL']; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) { + this.yylloc.range = [0,0]; + } + this.offset = 0; + return this; + }, + +// consumes and returns one char from the input +input:function () { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) { + this.yylloc.range[1]++; + } + + this._input = this._input.slice(1); + return ch; + }, + +// unshifts one char (or a string) into the input +unput:function (ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); + //this.yyleng -= len; + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + var r = this.yylloc.range; + + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? + (lines.length === oldLines.length ? this.yylloc.first_column : 0) + + oldLines[oldLines.length - lines.length].length - lines[0].length : + this.yylloc.first_column - len + }; + + if (this.options.ranges) { + this.yylloc.range = [r[0], r[0] + this.yyleng - len]; + } + this.yyleng = this.yytext.length; + return this; + }, + +// When called from action, caches matched text and appends it on next action +more:function () { + this._more = true; + return this; + }, + +// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. +reject:function () { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + + } + return this; + }, + +// retain first n characters of the match +less:function (n) { + this.unput(this.match.slice(n)); + }, + +// displays already matched input, i.e. for error messages +pastInput:function () { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); + }, + +// displays upcoming input, i.e. for error messages +upcomingInput:function () { + var next = this.match; + if (next.length < 20) { + next += this._input.substr(0, 20-next.length); + } + return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, ""); + }, + +// displays the character position where the lexing error occurred, i.e. for error messages +showPosition:function () { + var pre = this.pastInput(); + var c = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c + "^"; + }, + +// test the lexed token: return FALSE when not a match, otherwise return token +test_match:function(match, indexed_rule) { + var token, + lines, + backup; + + if (this.options.backtrack_lexer) { + // save context + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + + lines = match[0].match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno += lines.length; + } + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? + lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : + this.yylloc.last_column + match[0].length + }; + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) { + this.done = false; + } + if (token) { + return token; + } else if (this._backtrack) { + // recover context + for (var k in backup) { + this[k] = backup[k]; + } + return false; // rule action called reject() implying the next rule should be tested instead. + } + return false; + }, + +// return next match in input +next:function () { + if (this.done) { + return this.EOF; + } + if (!this._input) { + this.done = true; + } + + var token, + match, + tempMatch, + index; + if (!this._more) { + this.yytext = ''; + this.match = ''; + } + var rules = this._currentRules(); + for (var i = 0; i < rules.length; i++) { + tempMatch = this._input.match(this.rules[rules[i]]); + if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { + match = tempMatch; + index = i; + if (this.options.backtrack_lexer) { + token = this.test_match(tempMatch, rules[i]); + if (token !== false) { + return token; + } else if (this._backtrack) { + match = false; + continue; // rule action called reject() implying a rule MISmatch. + } else { + // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + if (match) { + token = this.test_match(match, rules[index]); + if (token !== false) { + return token; + } + // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + return false; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, + +// return next match that has a token +lex:function lex () { + var r = this.next(); + if (r) { + return r; + } else { + return this.lex(); + } + }, + +// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) +begin:function begin (condition) { + this.conditionStack.push(condition); + }, + +// pop the previously active lexer condition state off the condition stack +popState:function popState () { + var n = this.conditionStack.length - 1; + if (n > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, + +// produce the lexer rule set which is active for the currently active lexer condition state +_currentRules:function _currentRules () { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, + +// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available +topState:function topState (n) { + n = this.conditionStack.length - 1 - Math.abs(n || 0); + if (n >= 0) { + return this.conditionStack[n]; + } else { + return "INITIAL"; + } + }, + +// alias for begin(condition) +pushState:function pushState (condition) { + this.begin(condition); + }, + +// return the number of states currently on the stack +stateStackSize:function stateStackSize() { + return this.conditionStack.length; + }, +options: {"case-insensitive":true,"flex":true}, +performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { +var YYSTATE=YY_START; +switch($avoiding_name_collisions) { +case 0: /* skip whitespace */ +break; +case 1: /* skip comments */ +break; +case 2: /* skip comments */ +break; +case 3: parser.yy.partialCursor = false; parser.yy.cursorFound = yy_.yylloc; return 22; +break; +case 4: parser.yy.partialCursor = true; parser.yy.cursorFound = yy_.yylloc; return 263; +break; +case 5: this.popState(); return 326; +break; +case 6: return 99; +break; +case 7: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('ALTER', yy_.yylloc, yy.lexer.upcomingInput()); return 'ALTER'; +break; +case 8: return 212; +break; +case 9: return 20; +break; +case 10: return 88; +break; +case 11: this.begin('between'); return 215; +break; +case 12: return 216; +break; +case 13: return 217; +break; +case 14: return 36; +break; +case 15: return 278; +break; +case 16: return 218; +break; +case 17: return 219; +break; +case 18: return 'COLUMNS'; +break; +case 19: return 'COMMENT'; +break; +case 20: parser.determineCase(yy_.yytext); return 189; +break; +case 21: return 63; +break; +case 22: return 221; +break; +case 23: return 222; +break; +case 24: return 223; +break; +case 25: return 89; +break; +case 26: return 100; +break; +case 27: return 213; +break; +case 28: return 224; +break; +case 29: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('DROP', yy_.yylloc, yy.lexer.upcomingInput()); return 'DROP'; +break; +case 30: return 226; +break; +case 31: return 227; +break; +case 32: parser.yy.correlatedSubQuery = true; return 228; +break; +case 33: return 229; +break; +case 34: return 230; +break; +case 35: return 231; +break; +case 36: parser.determineCase(yy_.yytext); return 27; +break; +case 37: return 65; +break; +case 38: return 35; +break; +case 39: return 50; +break; +case 40: return 154; +break; +case 41: return 233; +break; +case 42: return 67; +break; +case 43: return 'INSERT'; +break; +case 44: return 234; +break; +case 45: return 235; +break; +case 46: return 236; +break; +case 47: return 64; +break; +case 48: return 68; +break; +case 49: return 237; +break; +case 50: return 75; +break; +case 51: return 238; +break; +case 52: return 163; +break; +case 53: return 71; +break; +case 54: return 201; +break; +case 55: return 239; +break; +case 56: return 81; +break; +case 57: return 66; +break; +case 58: return 240; +break; +case 59: return 241; +break; +case 60: return 242; +break; +case 61: return 243; +break; +case 62: return 244; +break; +case 63: return 70; +break; +case 64: return 245; +break; +case 65: return 246; +break; +case 66: return 200; +break; +case 67: return 247; +break; +case 68: return 248; +break; +case 69: return 'SCHEMAS'; +break; +case 70: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SELECT', yy_.yylloc); return 90; +break; +case 71: return 69; +break; +case 72: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SET', yy_.yylloc); return 185; +break; +case 73: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SHOW', yy_.yylloc); return 'SHOW'; +break; +case 74: return 250; +break; +case 75: return 251; +break; +case 76: return 252; +break; +case 77: return 'TABLES'; +break; +case 78: return 253; +break; +case 79: return 254; +break; +case 80: return 255; +break; +case 81: return 'TO'; +break; +case 82: return 256; +break; +case 83: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('TRUNCATE', yy_.yylloc, yy.lexer.upcomingInput()); return 156; +break; +case 84: return 383; +break; +case 85: return 115; +break; +case 86: parser.determineCase(yy_.yytext); return 'UPDATE'; +break; +case 87: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('USE', yy_.yylloc); return 'USE'; +break; +case 88: return 259; +break; +case 89: return 260; +break; +case 90: return 'VIEW'; +break; +case 91: return 261; +break; +case 92: return 117; +break; +case 93: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('WITH', yy_.yylloc); return 13; +break; +case 94: return 171; +break; +case 95: return 200; +break; +case 96: yy.lexer.unput('('); yy_.yytext = 'avg'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 141; +break; +case 97: yy.lexer.unput('('); yy_.yytext = 'cast'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 157; +break; +case 98: yy.lexer.unput('('); yy_.yytext = 'count'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 149; +break; +case 99: yy.lexer.unput('('); yy_.yytext = 'max'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 142; +break; +case 100: yy.lexer.unput('('); yy_.yytext = 'min'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 143; +break; +case 101: yy.lexer.unput('('); yy_.yytext = 'stddev_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 144; +break; +case 102: yy.lexer.unput('('); yy_.yytext = 'stddev_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 145; +break; +case 103: yy.lexer.unput('('); yy_.yytext = 'sum'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 150; +break; +case 104: yy.lexer.unput('('); yy_.yytext = 'var_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 146; +break; +case 105: yy.lexer.unput('('); yy_.yytext = 'var_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 147; +break; +case 106: yy.lexer.unput('('); yy_.yytext = 'variance'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 107: yy.lexer.unput('('); yy_.yytext = 'cume_dist'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 108: yy.lexer.unput('('); yy_.yytext = 'dense_rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 109: yy.lexer.unput('('); yy_.yytext = 'first_value'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 110: yy.lexer.unput('('); yy_.yytext = 'lag'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 111: yy.lexer.unput('('); yy_.yytext = 'last_value'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 112: yy.lexer.unput('('); yy_.yytext = 'lead'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 113: yy.lexer.unput('('); yy_.yytext = 'rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 114: yy.lexer.unput('('); yy_.yytext = 'row_number'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 151; +break; +case 115: return 257; +break; +case 116: return 257; +break; +case 117: return 258; +break; +case 118: return 203; +break; +case 119: parser.yy.cursorFound = true; return 22; +break; +case 120: parser.yy.cursorFound = true; return 263; +break; +case 121: return 232; +break; +case 122: parser.addFileLocation(yy_.yylloc, yy_.yytext); return 388; +break; +case 123: this.popState(); return 389; +break; +case 124: return 194; +break; +case 125: return 212; +break; +case 126: return 239; +break; +case 127: return 187; +break; +case 128: return 207; +break; +case 129: return 208; +break; +case 130: return 220; +break; +case 131: return 220; +break; +case 132: return 220; +break; +case 133: return 220; +break; +case 134: return 220; +break; +case 135: return 205; +break; +case 136: return 106; +break; +case 137: return 213; +break; +case 138: return 213; +break; +case 139: return 213; +break; +case 140: return 213; +break; +case 141: return 213; +break; +case 142: return 213; +break; +case 143: return 17; +break; +case 144: return 206; +break; +case 145: return ':'; +break; +case 146: return 177; +break; +case 147: return 211; +break; +case 148: return 204; +break; +case 149: return 7; +break; +case 150: return 8; +break; +case 151: return 209; +break; +case 152: return 210; +break; +case 153: return 77; +break; +case 154: this.begin('backtickedValue'); return 214; +break; +case 155: + if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '`')) { + return 268; + } + return 266; + +break; +case 156: this.popState(); return 214; +break; +case 157: this.begin('singleQuotedValue'); return 249; +break; +case 158: + if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '\'')) { + return 268; + } + return 266; + +break; +case 159: this.popState(); return 249; +break; +case 160: this.begin('doubleQuotedValue'); return 225; +break; +case 161: + if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '"')) { + return 268; + } + return 266; + +break; +case 162: this.popState(); return 225; +break; +case 163: return 194; +break; +case 164: /* To prevent console logging of unknown chars */ +break; +case 165: +break; +case 166: +break; +case 167: +break; +case 168: +break; +case 169: +break; +case 170:console.log(yy_.yytext); +break; +} +}, +rules: [/^(?:\s)/i,/^(?:--.*)/i,/^(?:[/][*][^*]*[*]+([^/*][^*]*[*]+)*[/])/i,/^(?:\u2020)/i,/^(?:\u2021)/i,/^(?:AND)/i,/^(?:ALL)/i,/^(?:ALTER)/i,/^(?:AND)/i,/^(?:AS)/i,/^(?:ASC)/i,/^(?:BETWEEN)/i,/^(?:BIGINT)/i,/^(?:BOOLEAN)/i,/^(?:BY)/i,/^(?:CASCADE)/i,/^(?:CASE)/i,/^(?:CHAR)/i,/^(?:COLUMNS)/i,/^(?:COMMENT)/i,/^(?:CREATE)/i,/^(?:CROSS)/i,/^(?:CURRENT)/i,/^(?:DATABASE)/i,/^(?:DECIMAL)/i,/^(?:DESC)/i,/^(?:DISTINCT)/i,/^(?:DIV)/i,/^(?:DOUBLE)/i,/^(?:DROP)/i,/^(?:ELSE)/i,/^(?:END)/i,/^(?:EXISTS)/i,/^(?:FALSE)/i,/^(?:FLOAT)/i,/^(?:FOLLOWING)/i,/^(?:FROM)/i,/^(?:FULL)/i,/^(?:GROUP)/i,/^(?:HAVING)/i,/^(?:IF)/i,/^(?:IN)/i,/^(?:INNER)/i,/^(?:INSERT)/i,/^(?:INT)/i,/^(?:INTO)/i,/^(?:IS)/i,/^(?:JOIN)/i,/^(?:LEFT)/i,/^(?:LIKE)/i,/^(?:LIMIT)/i,/^(?:NOT)/i,/^(?:NULL)/i,/^(?:ON)/i,/^(?:OPTION)/i,/^(?:OR)/i,/^(?:ORDER)/i,/^(?:OUTER)/i,/^(?:PARTITION)/i,/^(?:PRECEDING)/i,/^(?:PURGE)/i,/^(?:RANGE)/i,/^(?:REGEXP)/i,/^(?:RIGHT)/i,/^(?:RLIKE)/i,/^(?:ROW)/i,/^(?:ROLE)/i,/^(?:ROWS)/i,/^(?:SCHEMA)/i,/^(?:SCHEMAS)/i,/^(?:SELECT)/i,/^(?:SEMI)/i,/^(?:SET)/i,/^(?:SHOW)/i,/^(?:SMALLINT)/i,/^(?:STRING)/i,/^(?:TABLE)/i,/^(?:TABLES)/i,/^(?:THEN)/i,/^(?:TIMESTAMP)/i,/^(?:TINYINT)/i,/^(?:TO)/i,/^(?:TRUE)/i,/^(?:TRUNCATE)/i,/^(?:UNBOUNDED)/i,/^(?:UNION)/i,/^(?:UPDATE)/i,/^(?:USE)/i,/^(?:VALUES)/i,/^(?:VARCHAR)/i,/^(?:VIEW)/i,/^(?:WHEN)/i,/^(?:WHERE)/i,/^(?:WITH)/i,/^(?:OVER)/i,/^(?:ROLE)/i,/^(?:AVG\s*\()/i,/^(?:CAST\s*\()/i,/^(?:COUNT\s*\()/i,/^(?:MAX\s*\()/i,/^(?:MIN\s*\()/i,/^(?:STDDEV_POP\s*\()/i,/^(?:STDDEV_SAMP\s*\()/i,/^(?:SUM\s*\()/i,/^(?:VAR_POP\s*\()/i,/^(?:VAR_SAMP\s*\()/i,/^(?:VARIANCE\s*\()/i,/^(?:CUME_DIST\s*\()/i,/^(?:DENSE_RANK\s*\()/i,/^(?:FIRST_VALUE\s*\()/i,/^(?:LAG\s*\()/i,/^(?:LAST_VALUE\s*\()/i,/^(?:LEAD\s*\()/i,/^(?:RANK\s*\()/i,/^(?:ROW_NUMBER\s*\()/i,/^(?:[0-9]+)/i,/^(?:[0-9]+(?:[YSL]|BD)?)/i,/^(?:[0-9]+E)/i,/^(?:[A-Za-z0-9_]+)/i,/^(?:\u2020)/i,/^(?:\u2021)/i,/^(?:\s+['"])/i,/^(?:[^'"\u2020\u2021]+)/i,/^(?:['"])/i,/^(?:$)/i,/^(?:&&)/i,/^(?:\|\|)/i,/^(?:=)/i,/^(?:<)/i,/^(?:>)/i,/^(?:!=)/i,/^(?:<=)/i,/^(?:>=)/i,/^(?:<>)/i,/^(?:<=>)/i,/^(?:-)/i,/^(?:\*)/i,/^(?:\+)/i,/^(?:\/)/i,/^(?:%)/i,/^(?:\|)/i,/^(?:\^)/i,/^(?:&)/i,/^(?:,)/i,/^(?:\.)/i,/^(?::)/i,/^(?:;)/i,/^(?:~)/i,/^(?:!)/i,/^(?:\()/i,/^(?:\))/i,/^(?:\[)/i,/^(?:\])/i,/^(?:\$\{[^}]*\})/i,/^(?:`)/i,/^(?:[^`]+)/i,/^(?:`)/i,/^(?:')/i,/^(?:(?:\\\\|\\[']|[^'])+)/i,/^(?:')/i,/^(?:")/i,/^(?:(?:\\\\|\\["]|[^"])+)/i,/^(?:")/i,/^(?:$)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i], +conditions: {"hdfs":{"rules":[119,120,121,122,123,124,166],"inclusive":false},"doubleQuotedValue":{"rules":[161,162,169],"inclusive":false},"singleQuotedValue":{"rules":[158,159,168],"inclusive":false},"backtickedValue":{"rules":[155,156,167],"inclusive":false},"between":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,157,160,163,164,165,170],"inclusive":true},"INITIAL":{"rules":[0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,157,160,163,164,170],"inclusive":true}} +}); +return lexer; +})(); +parser.lexer = lexer; +function Parser () { + this.yy = {}; +} +Parser.prototype = parser;parser.Parser = Parser; +return new Parser; +})(); +export default sparksqlAutocompleteParser; diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.test.ts b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.test.ts new file mode 100644 index 00000000000..9f13793e31e --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlAutocompleteParser.test.ts @@ -0,0 +1,35 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// 'License'); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an 'AS IS' BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import sparksqlAutocompleteParser from './sparksqlAutocompleteParser'; +import structure from './jison/structure.json'; +import { AutocompleteParser } from '../../types'; +import { extractTestCases, runTestCases } from '../testUtils'; +import { assertPartials, CommonParser } from '../sharedParserTests'; + +const jisonFolder = 'desktop/core/src/desktop/js/parse/sql/sparksql/jison'; +const groupedTestCases = extractTestCases(jisonFolder, structure.autocomplete); + +describe('sparksqlAutocompleteParser', () => { + // TODO: Fix the types + runTestCases(sparksqlAutocompleteParser as unknown as AutocompleteParser, groupedTestCases); + + describe('partial removal', () => { + it('should identify part lengths', () => { + assertPartials(sparksqlAutocompleteParser as unknown as CommonParser); + }); + }); +}); diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.js b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.js new file mode 100644 index 00000000000..b4524731f0c --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.js @@ -0,0 +1,3430 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +/* parser generated by jison 0.4.17 */ +/* + Returns a Parser object of the following structure: + + Parser: { + yy: {} + } + + Parser.prototype: { + yy: {}, + trace: function(), + symbols_: {associative list: name ==> number}, + terminals_: {associative list: number ==> name}, + productions_: [...], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$), + table: [...], + defaultActions: {...}, + parseError: function(str, hash), + parse: function(input), + + lexer: { + EOF: 1, + parseError: function(str, hash), + setInput: function(input), + input: function(), + unput: function(str), + more: function(), + less: function(n), + pastInput: function(), + upcomingInput: function(), + showPosition: function(), + test_match: function(regex_match_array, rule_index), + next: function(), + lex: function(), + begin: function(condition), + popState: function(), + _currentRules: function(), + topState: function(), + pushState: function(condition), + + options: { + ranges: boolean (optional: true ==> token location info will include a .range[] member) + flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match) + backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code) + }, + + performAction: function(yy, yy_, $avoiding_name_collisions, YY_START), + rules: [...], + conditions: {associative list: name ==> set}, + } + } + + + token location info (@$, _$, etc.): { + first_line: n, + last_line: n, + first_column: n, + last_column: n, + range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based) + } + + + the parseError function receives a 'hash' object with these members for lexer and parser errors: { + text: (matched text) + token: (the produced terminal token, if any) + line: (yylineno) + } + while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: { + loc: (yylloc) + expected: (string describing the set of expected tokens) + recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error) + } +*/ +import SqlParseSupport from 'parse/sql/sparksql/sqlParseSupport'; + +var sparksqlSyntaxParser = (function(){ +var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[13,90,173,177,179,180],$V1=[2,315],$V2=[173,177],$V3=[2,316],$V4=[1,10],$V5=[1,11],$V6=[1,5],$V7=[1,6],$V8=[8,173,177],$V9=[2,192],$Va=[1,19],$Vb=[1,26],$Vc=[1,28],$Vd=[1,29],$Ve=[1,30],$Vf=[1,25],$Vg=[1,24],$Vh=[2,154],$Vi=[1,32],$Vj=[1,33],$Vk=[8,112,173,177],$Vl=[7,17,90],$Vm=[7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,103,112,114,173,177,185,186,187,188,191,192,193,194,195,199,200,201,202,207,212,213,214,220,223,224,225,226,230,231,232,234,237,241,249,316],$Vn=[1,53],$Vo=[1,46],$Vp=[1,86],$Vq=[1,87],$Vr=[1,88],$Vs=[1,89],$Vt=[1,90],$Vu=[1,91],$Vv=[1,92],$Vw=[1,93],$Vx=[1,79],$Vy=[1,80],$Vz=[1,73],$VA=[1,61],$VB=[1,62],$VC=[1,63],$VD=[1,64],$VE=[1,74],$VF=[1,59],$VG=[1,49],$VH=[1,51],$VI=[1,95],$VJ=[1,50],$VK=[1,54],$VL=[1,98],$VM=[1,52],$VN=[1,100],$VO=[1,48],$VP=[1,97],$VQ=[1,99],$VR=[1,94],$VS=[1,96],$VT=[7,8,77,90,103,138,139,140,141,142,143,144,145,146,147,148,150,151,152,153,154,160,185,186,187,188,190,191,192,198,201,205,212,215,216,225,237,244,245,246],$VU=[8,17,27,112,173,177],$VV=[2,791],$VW=[1,128],$VX=[1,123],$VY=[1,122],$VZ=[1,114],$V_=[1,113],$V$=[1,115],$V01=[1,121],$V11=[1,124],$V21=[1,119],$V31=[1,116],$V41=[1,118],$V51=[1,112],$V61=[1,129],$V71=[1,117],$V81=[1,120],$V91=[1,131],$Va1=[1,130],$Vb1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,103,112,114,173,177,185,186,187,188,191,193,194,195,199,200,201,202,207,212,213,214,220,223,224,225,226,230,231,232,234,237,241,249,316],$Vc1=[1,139],$Vd1=[1,145],$Ve1=[1,147],$Vf1=[7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,103,112,114,173,177,185,186,187,188,191,193,194,195,199,200,201,202,207,212,213,214,220,223,224,225,226,230,231,232,234,237,241,249,316],$Vg1=[1,152],$Vh1=[7,8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,103,112,114,173,177,185,186,187,188,191,192,193,194,195,199,200,201,202,207,212,213,214,220,223,224,225,226,230,231,232,234,237,241,249,316],$Vi1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,103,112,114,168,173,177,185,186,187,188,191,193,194,195,199,200,201,202,207,212,213,214,220,223,224,225,226,230,231,232,234,237,241,249,316],$Vj1=[13,90],$Vk1=[2,769],$Vl1=[8,35,50,75,81,112,173,177],$Vm1=[97,160,216,244],$Vn1=[8,17,27,35,50,63,64,65,66,67,68,69,70,71,75,81,112,114,173,177],$Vo1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,112,114,173,177,185,186,187,188,199,201,202,212,213,214,225,226,230,234,237,241,249,316],$Vp1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,103,112,114,173,177,185,186,187,188,191,193,194,195,199,200,201,202,207,212,213,214,225,226,230,234,237,241,249,316],$Vq1=[213,214,249],$Vr1=[7,77,138,139,140,141,142,143,144,145,146,147,148,150,151,152,153,154,160,185,186,187,188,190,191,192,198,201,205,212,215,216,225,237,244,245,246],$Vs1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,71,75,77,81,88,89,103,112,114,173,177,185,186,187,188,191,193,194,195,199,200,201,202,207,212,213,214,220,223,224,225,226,230,231,232,234,237,241,249,316],$Vt1=[8,50,75,81,112,173,177],$Vu1=[8,17,35,50,75,81,112,114,173,177],$Vv1=[1,255],$Vw1=[1,258],$Vx1=[1,256],$Vy1=[1,260],$Vz1=[1,257],$VA1=[1,259],$VB1=[1,262],$VC1=[1,261],$VD1=[8,17,35,50,63,64,65,66,67,68,69,70,71,75,81,112,114,173,177],$VE1=[8,17,20,35,50,63,64,65,66,67,68,69,70,71,75,77,81,112,114,173,177,185,186,187,188,201,212,237],$VF1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,112,114,173,177,185,186,187,188,193,194,195,199,201,202,207,212,213,214,225,226,230,234,237,241,249,316],$VG1=[8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,112,114,173,177,185,186,187,188,199,201,212,213,214,226,230,234,237,241,249,316],$VH1=[1,281],$VI1=[8,17],$VJ1=[8,81],$VK1=[8,75,81,112,173,177],$VL1=[7,77,185,186,187,188,201],$VM1=[1,321],$VN1=[8,17,81],$VO1=[1,329],$VP1=[8,75,112,173,177],$VQ1=[8,17,35,50,63,64,65,66,67,68,69,70,75,81,112,114,173,177],$VR1=[2,113],$VS1=[1,354],$VT1=[1,377],$VU1=[2,581],$VV1=[8,17,50,75,81,112,173,177],$VW1=[202,373],$VX1=[8,199,208,245,373],$VY1=[2,827],$VZ1=[8,17,75,112,173,177,230,234],$V_1=[8,199],$V$1=[2,837],$V02=[1,410],$V12=[1,411],$V22=[1,412],$V32=[2,842],$V42=[1,419],$V52=[218,228]; +var parser = {trace: function trace () { }, +yy: {}, +symbols_: {"error":2,"QuerySpecification":3,"CommonTableExpression":4,"SelectStatement":5,"OptionalUnions":6,"(":7,")":8,"QuerySpecification_EDIT":9,"SelectStatement_EDIT":10,"OptionalUnions_EDIT":11,"CommonTableExpression_EDIT":12,"WITH":13,"WithQueries":14,"WithQueries_EDIT":15,"WithQuery":16,",":17,"WithQuery_EDIT":18,"RegularOrBacktickedIdentifier":19,"AS":20,"TableSubQueryInner":21,"CURSOR":22,"AnyCursor":23,"RightParenthesisOrError":24,"TableSubQueryInner_EDIT":25,"FromClause":26,"FROM":27,"TableReferenceList":28,"FromClause_EDIT":29,"TableReferenceList_EDIT":30,"TableReference":31,"TableReference_EDIT":32,"OptionalGroupByClause":33,"GroupByClause":34,"GROUP":35,"BY":36,"GroupByColumnList":37,"GroupByClause_EDIT":38,"GroupByColumnList_EDIT":39,"ColumnGroupingSets":40,"ColumnReference":41,"ColumnGroupingSets_EDIT":42,"ColumnGroupingSet_EDIT":43,"ColumnReference_EDIT":44,"ValueExpression":45,"ValueExpression_EDIT":46,"GroupByColumnListPartTwo_EDIT":47,"OptionalHavingClause":48,"HavingClause":49,"HAVING":50,"HavingClause_EDIT":51,"OptionalJoins":52,"Joins":53,"Joins_INVALID":54,"JoinType":55,"TablePrimary":56,"OptionalJoinCondition":57,"Join_EDIT":58,"JoinType_EDIT":59,"TablePrimary_EDIT":60,"JoinCondition_EDIT":61,"Joins_EDIT":62,"CROSS":63,"JOIN":64,"FULL":65,"OUTER":66,"INNER":67,"LEFT":68,"SEMI":69,"RIGHT":70,"ON":71,"UsingColList":72,"OptionalLimitClause":73,"LimitClause":74,"LIMIT":75,"UnsignedNumericLiteral":76,"VARIABLE_REFERENCE":77,"LimitClause_EDIT":78,"OptionalOrderByClause":79,"OrderByClause":80,"ORDER":81,"OrderByColumnList":82,"OrderByClause_EDIT":83,"OrderByColumnList_EDIT":84,"OrderByIdentifier":85,"OrderByIdentifier_EDIT":86,"OptionalAscOrDesc":87,"ASC":88,"DESC":89,"SELECT":90,"OptionalAllOrDistinct":91,"SelectList":92,"TableExpression":93,"SelectList_EDIT":94,"TableExpression_EDIT":95,"ALL":96,"DISTINCT":97,"OptionalSelectConditions":98,"OptionalSelectConditions_EDIT":99,"SelectSpecification":100,"SelectSpecification_EDIT":101,"OptionalCorrelationName":102,"*":103,"OptionalCorrelationName_EDIT":104,"OptionalWhereClause":105,"WhereClause_EDIT":106,"WhereClause":107,"Unions":108,"Unions_EDIT":109,"UnionClause":110,"UnionClause_EDIT":111,"UNION":112,"NewStatement":113,"WHERE":114,"SearchCondition":115,"SearchCondition_EDIT":116,"UserDefinedFunction":117,"AggregateFunction":118,"OptionalOverClause":119,"AnalyticFunction":120,"OverClause":121,"CastFunction":122,"UserDefinedFunction_EDIT":123,"AggregateFunction_EDIT":124,"OptionalOverClause_EDIT":125,"AnalyticFunction_EDIT":126,"OverClause_EDIT":127,"CastFunction_EDIT":128,"OtherAggregateFunction":129,"CountFunction":130,"SumFunction":131,"OtherAggregateFunction_EDIT":132,"CountFunction_EDIT":133,"SumFunction_EDIT":134,"OtherAggregateFunction_Type":135,"UdfArgumentList":136,"UdfArgumentList_EDIT":137,"AVG":138,"MAX":139,"MIN":140,"STDDEV_POP":141,"STDDEV_SAMP":142,"VAR_POP":143,"VAR_SAMP":144,"VARIANCE":145,"COUNT":146,"SUM":147,"ANALYTIC":148,"ArbitraryFunctionName":149,"ARRAY":150,"IF":151,"MAP":152,"TRUNCATE":153,"CAST":154,"PrimitiveType":155,"NonParenthesizedValueExpressionPrimary":156,"ColumnOrArbitraryFunctionRef":157,"ArbitraryFunctionRightPart":158,"UnsignedValueSpecification":159,"NULL":160,"NonParenthesizedValueExpressionPrimary_EDIT":161,"ArbitraryFunctionRightPart_EDIT":162,"UnsignedValueSpecification_EDIT":163,"ColumnOrArbitraryFunctionRef_EDIT":164,"ArbitraryFunction":165,"RegularIdentifier":166,"ArbitraryFunction_EDIT":167,"OVER":168,"WindowExpression":169,"WindowExpression_EDIT":170,"SqlSyntax":171,"SqlStatements":172,"EOF":173,"SqlAutocomplete":174,"SqlStatements_EDIT":175,"SqlStatement":176,";":177,"SqlStatement_EDIT":178,"DataDefinition":179,"DataManipulation":180,"DataDefinition_EDIT":181,"DataManipulation_EDIT":182,"SetSpecification_EDIT":183,"NonReservedKeyword":184,"ROLE":185,"OPTION":186,"STRUCT":187,"REGULAR_IDENTIFIER":188,"NonStartingToken":189,"!":190,"-":191,".":192,"<":193,"=":194,">":195,"[":196,"]":197,"~":198,"AND":199,"ARITHMETIC_OPERATOR":200,"BACKTICK":201,"BETWEEN":202,"BIGINT":203,"BOOLEAN":204,"CASE":205,"CHAR":206,"COMPARISON_OPERATOR":207,"CURRENT":208,"DATABASE":209,"DECIMAL":210,"DOUBLE":211,"DOUBLE_QUOTE":212,"ELSE":213,"END":214,"EXISTS":215,"FALSE":216,"FLOAT":217,"FOLLOWING":218,"HDFS_START_QUOTE":219,"IN":220,"INT":221,"INTO":222,"IS":223,"LIKE":224,"NOT":225,"OR":226,"PARTITION":227,"PRECEDING":228,"PURGE":229,"RANGE":230,"REGEXP":231,"RLIKE":232,"ROW":233,"ROWS":234,"SCHEMA":235,"SET":236,"SINGLE_QUOTE":237,"SMALLINT":238,"STRING":239,"TABLE":240,"THEN":241,"TIMESTAMP":242,"TINYINT":243,"TRUE":244,"UNSIGNED_INTEGER":245,"UNSIGNED_INTEGER_E":246,"VALUES":247,"VARCHAR":248,"WHEN":249,"Commas":250,"PARTIAL_CURSOR":251,"FromOrIn":252,"DatabaseOrSchema":253,"SingleQuotedValue":254,"VALUE":255,"SingleQuotedValue_EDIT":256,"PARTIAL_VALUE":257,"DoubleQuotedValue":258,"DoubleQuotedValue_EDIT":259,"QuotedValue":260,"QuotedValue_EDIT":261,"OptionalFromDatabase":262,"DatabaseIdentifier":263,"OptionalFromDatabase_EDIT":264,"DatabaseIdentifier_EDIT":265,"OptionalCascade":266,"CASCADE":267,"OptionalIfExists":268,"OptionalIfExists_EDIT":269,"OptionalIfNotExists":270,"OptionalIfNotExists_EDIT":271,"OptionalInDatabase":272,"OptionalPartitionSpec":273,"PartitionSpec":274,"OptionalPartitionSpec_EDIT":275,"PartitionSpec_EDIT":276,"PartitionSpecList":277,"PartitionSpecList_EDIT":278,"RangePartitionSpec":279,"RangePartitionComparisonOperator":280,"RangePartitionSpec_EDIT":281,"ConfigurationName":282,"PartialBacktickedOrAnyCursor":283,"PartialBacktickedIdentifier":284,"PartialBacktickedOrCursor":285,"PartialBacktickedOrPartialCursor":286,"OptionalParenthesizedColumnList":287,"ParenthesizedColumnList":288,"OptionalParenthesizedColumnList_EDIT":289,"ParenthesizedColumnList_EDIT":290,"ColumnList":291,"ColumnList_EDIT":292,"ColumnIdentifier":293,"ParenthesizedSimpleValueList":294,"SimpleValueList":295,"SchemaQualifiedTableIdentifier":296,"SchemaQualifiedTableIdentifier_EDIT":297,"SchemaQualifiedIdentifier":298,"SchemaQualifiedIdentifier_EDIT":299,"PartitionExpression":300,"PartitionExpression_EDIT":301,"RegularOrBackTickedSchemaQualifiedName":302,"RegularOrBackTickedSchemaQualifiedName_EDIT":303,"LocalOrSchemaQualifiedName":304,"LocalOrSchemaQualifiedName_EDIT":305,"BasicIdentifierChain":306,"BasicIdentifierChain_EDIT":307,"DerivedColumnChain":308,"DerivedColumnChain_EDIT":309,"PartialBacktickedIdentifierOrPartialCursor":310,"OptionalTypeLength":311,"OptionalTypePrecision":312,"OptionalNot":313,"TableSubQuery":314,"ValueExpressionList":315,"BETWEEN_AND":316,"LikeRightPart":317,"CaseRightPart":318,"TableSubQuery_EDIT":319,"ValueExpressionInSecondPart_EDIT":320,"LikeRightPart_EDIT":321,"CaseRightPart_EDIT":322,"EndOrError":323,"ValueExpressionList_EDIT":324,"InValueList":325,"SignedInteger":326,"+":327,"UnsignedLiteral":328,"UnsignedLiteral_EDIT":329,"GeneralLiteral":330,"GeneralLiteral_EDIT":331,"ExactNumericLiteral":332,"ApproximateNumericLiteral":333,"TruthValue":334,"TablePrimaryOrJoinedTable":335,"TablePrimaryOrJoinedTable_EDIT":336,"JoinedTable":337,"JoinedTable_EDIT":338,"TableOrQueryName":339,"DerivedTable":340,"TableOrQueryName_EDIT":341,"DerivedTable_EDIT":342,"OptionalOnColumn":343,"OptionalOnColumn_EDIT":344,"PushQueryState":345,"PopQueryState":346,"SubQuery":347,"SubQuery_EDIT":348,"QueryExpression":349,"QueryExpression_EDIT":350,"QueryExpressionBody":351,"QueryExpressionBody_EDIT":352,"NonJoinQueryExpression":353,"NonJoinQueryExpression_EDIT":354,"NonJoinQueryTerm":355,"NonJoinQueryTerm_EDIT":356,"NonJoinQueryPrimary":357,"NonJoinQueryPrimary_EDIT":358,"SimpleTable":359,"SimpleTable_EDIT":360,"OptionalPartitionBy":361,"OptionalOrderByAndWindow":362,"PartitionBy_EDIT":363,"OptionalOrderByAndWindow_EDIT":364,"PartitionBy":365,"OptionalWindowSpec":366,"WindowSpec_EDIT":367,"WindowSpec":368,"RowsOrRange":369,"PopLexerState":370,"OptionalCurrentOrPreceding":371,"OptionalAndFollowing":372,"UNBOUNDED":373,"OptionalCurrentOrPreceding_EDIT":374,"OptionalAndFollowing_EDIT":375,"PushHdfsLexerState":376,"HdfsPath":377,"HDFS_PATH":378,"HDFS_END_QUOTE":379,"HdfsPath_EDIT":380,"IntegerOrUnbounded":381,"CaseWhenThenList":382,"CaseWhenThenList_EDIT":383,"CaseWhenThenListPartTwo":384,"CaseWhenThenListPartTwo_EDIT":385,"$accept":0,"$end":1}, +terminals_: {2:"error",7:"(",8:")",13:"WITH",17:",",20:"AS",22:"CURSOR",27:"FROM",35:"GROUP",36:"BY",50:"HAVING",63:"CROSS",64:"JOIN",65:"FULL",66:"OUTER",67:"INNER",68:"LEFT",69:"SEMI",70:"RIGHT",71:"ON",75:"LIMIT",77:"VARIABLE_REFERENCE",81:"ORDER",88:"ASC",89:"DESC",90:"SELECT",96:"ALL",97:"DISTINCT",103:"*",112:"UNION",114:"WHERE",138:"AVG",139:"MAX",140:"MIN",141:"STDDEV_POP",142:"STDDEV_SAMP",143:"VAR_POP",144:"VAR_SAMP",145:"VARIANCE",146:"COUNT",147:"SUM",148:"ANALYTIC",150:"ARRAY",151:"IF",152:"MAP",153:"TRUNCATE",154:"CAST",160:"NULL",168:"OVER",173:"EOF",177:";",179:"DataDefinition",180:"DataManipulation",181:"DataDefinition_EDIT",182:"DataManipulation_EDIT",183:"SetSpecification_EDIT",185:"ROLE",186:"OPTION",187:"STRUCT",188:"REGULAR_IDENTIFIER",190:"!",191:"-",192:".",193:"<",194:"=",195:">",196:"[",197:"]",198:"~",199:"AND",200:"ARITHMETIC_OPERATOR",201:"BACKTICK",202:"BETWEEN",203:"BIGINT",204:"BOOLEAN",205:"CASE",206:"CHAR",207:"COMPARISON_OPERATOR",208:"CURRENT",209:"DATABASE",210:"DECIMAL",211:"DOUBLE",212:"DOUBLE_QUOTE",213:"ELSE",214:"END",215:"EXISTS",216:"FALSE",217:"FLOAT",218:"FOLLOWING",219:"HDFS_START_QUOTE",220:"IN",221:"INT",222:"INTO",223:"IS",224:"LIKE",225:"NOT",226:"OR",227:"PARTITION",228:"PRECEDING",229:"PURGE",230:"RANGE",231:"REGEXP",232:"RLIKE",233:"ROW",234:"ROWS",235:"SCHEMA",236:"SET",237:"SINGLE_QUOTE",238:"SMALLINT",239:"STRING",240:"TABLE",241:"THEN",242:"TIMESTAMP",243:"TINYINT",244:"TRUE",245:"UNSIGNED_INTEGER",246:"UNSIGNED_INTEGER_E",247:"VALUES",248:"VARCHAR",249:"WHEN",251:"PARTIAL_CURSOR",255:"VALUE",257:"PARTIAL_VALUE",267:"CASCADE",316:"BETWEEN_AND",327:"+",373:"UNBOUNDED",378:"HDFS_PATH",379:"HDFS_END_QUOTE"}, +productions_: [0,[3,3],[3,5],[3,2],[9,4],[9,3],[9,3],[9,1],[9,4],[9,3],[9,2],[9,2],[4,2],[12,2],[14,1],[14,3],[15,1],[15,3],[15,3],[15,5],[16,5],[18,2],[18,5],[18,5],[26,2],[29,2],[29,2],[28,1],[28,3],[30,1],[30,3],[30,3],[30,5],[30,3],[33,0],[33,1],[34,3],[38,3],[38,3],[38,2],[40,0],[40,1],[40,3],[40,3],[42,1],[42,3],[42,3],[42,5],[42,3],[43,1],[43,1],[37,1],[37,3],[39,1],[39,2],[39,3],[39,3],[39,3],[39,4],[39,5],[47,1],[47,2],[47,1],[48,0],[48,1],[49,2],[51,2],[51,2],[52,0],[52,1],[52,1],[53,3],[53,4],[54,1],[54,2],[58,3],[58,1],[58,3],[58,3],[58,3],[62,1],[62,2],[62,2],[62,3],[55,2],[55,2],[55,3],[55,2],[55,1],[55,3],[55,2],[55,3],[55,3],[55,2],[55,3],[55,2],[55,3],[55,3],[55,2],[59,2],[59,3],[59,3],[59,2],[59,3],[59,3],[59,3],[59,3],[59,2],[59,3],[59,3],[59,3],[59,3],[59,2],[57,0],[57,2],[72,1],[72,3],[61,2],[61,2],[73,0],[73,1],[74,2],[74,4],[74,2],[74,4],[78,2],[79,0],[79,1],[80,3],[83,3],[83,2],[82,1],[82,3],[84,1],[84,2],[84,3],[84,4],[84,5],[85,2],[86,2],[86,2],[87,0],[87,1],[87,1],[5,3],[5,4],[10,3],[10,3],[10,4],[10,4],[10,4],[10,5],[10,6],[10,4],[91,0],[91,1],[91,1],[93,2],[95,2],[95,4],[95,3],[92,1],[92,3],[94,1],[94,2],[94,3],[94,3],[94,3],[94,4],[94,3],[94,3],[94,4],[94,4],[94,4],[94,5],[94,5],[100,2],[100,1],[101,2],[101,3],[101,2],[98,5],[99,5],[99,5],[99,5],[99,5],[99,5],[99,6],[99,6],[99,6],[99,6],[99,6],[6,0],[6,1],[11,1],[108,1],[108,2],[109,1],[109,2],[109,2],[109,3],[110,4],[111,3],[111,4],[111,4],[105,0],[105,1],[107,2],[106,2],[106,2],[115,1],[116,1],[117,2],[117,2],[117,1],[123,1],[123,2],[123,1],[123,2],[123,2],[123,2],[123,1],[118,1],[118,1],[118,1],[124,1],[124,1],[124,1],[129,4],[129,5],[132,5],[132,6],[132,5],[135,1],[135,1],[135,1],[135,1],[135,1],[135,1],[135,1],[135,1],[130,4],[130,3],[130,5],[133,5],[133,6],[133,5],[131,5],[131,3],[134,5],[134,6],[134,5],[120,3],[120,4],[126,4],[126,5],[126,4],[149,1],[149,1],[149,1],[149,1],[122,6],[122,3],[128,6],[128,5],[128,4],[128,6],[128,5],[128,4],[128,6],[128,5],[128,6],[128,5],[156,2],[156,2],[156,1],[156,1],[156,1],[156,1],[161,2],[161,2],[161,1],[161,1],[161,1],[165,2],[165,2],[167,2],[167,2],[158,2],[158,3],[162,3],[162,4],[162,3],[136,1],[136,3],[137,1],[137,3],[137,3],[137,5],[137,3],[137,5],[137,4],[137,3],[137,2],[137,2],[137,4],[119,0],[119,1],[125,1],[121,2],[121,2],[127,2],[171,3],[174,3],[174,3],[113,0],[172,0],[172,1],[172,4],[175,1],[175,4],[175,4],[175,7],[176,1],[176,1],[176,1],[178,1],[178,2],[178,1],[178,1],[178,1],[178,1],[184,1],[184,1],[184,1],[166,1],[166,1],[166,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[189,1],[250,1],[250,2],[23,1],[23,1],[252,1],[252,1],[253,1],[253,1],[254,3],[254,2],[256,2],[258,3],[258,2],[259,2],[260,1],[260,1],[261,1],[261,1],[262,0],[262,2],[264,2],[266,0],[266,1],[268,0],[268,2],[269,2],[270,0],[270,3],[271,2],[271,3],[272,0],[272,2],[272,2],[273,0],[273,1],[275,1],[274,4],[276,4],[279,5],[281,2],[281,3],[281,4],[281,5],[281,5],[281,5],[280,1],[280,1],[280,1],[280,1],[282,1],[282,1],[283,1],[283,1],[285,1],[285,1],[286,1],[286,1],[284,2],[24,1],[24,1],[287,0],[287,1],[289,1],[288,3],[290,3],[290,3],[291,1],[291,3],[292,3],[292,5],[294,3],[295,1],[295,3],[296,1],[296,3],[297,1],[297,3],[297,3],[298,1],[298,3],[299,1],[299,3],[299,3],[263,1],[265,1],[277,1],[277,3],[278,1],[278,3],[278,3],[278,5],[300,3],[301,3],[301,3],[301,3],[301,1],[19,1],[19,3],[19,2],[302,1],[302,3],[303,1],[303,3],[304,1],[304,2],[305,1],[305,2],[41,1],[41,3],[44,1],[306,1],[306,3],[307,3],[307,5],[308,1],[308,3],[309,1],[309,3],[309,5],[309,3],[293,1],[310,1],[310,1],[155,1],[155,1],[155,2],[155,2],[155,1],[155,1],[155,1],[155,1],[155,1],[155,1],[155,1],[155,2],[311,0],[311,3],[312,0],[312,3],[312,5],[45,1],[45,2],[45,2],[45,2],[45,2],[45,4],[45,4],[45,4],[45,6],[45,2],[45,3],[45,3],[45,3],[45,3],[45,3],[45,6],[45,6],[45,5],[45,5],[45,6],[45,5],[45,3],[45,3],[45,3],[45,3],[45,3],[45,2],[45,3],[45,2],[45,3],[46,1],[46,3],[46,2],[46,2],[46,2],[46,2],[46,2],[46,2],[46,2],[46,2],[46,3],[46,4],[46,5],[46,4],[46,4],[46,4],[46,6],[46,6],[46,2],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,4],[46,3],[46,6],[46,6],[46,5],[46,5],[46,6],[46,6],[46,6],[46,6],[46,5],[46,4],[46,5],[46,5],[46,5],[46,5],[46,4],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,3],[46,2],[46,3],[46,2],[46,3],[46,2],[46,3],[46,2],[46,3],[46,3],[46,4],[46,3],[46,3],[46,3],[315,1],[315,3],[324,1],[324,3],[324,3],[324,5],[324,3],[324,5],[324,4],[324,3],[324,2],[324,2],[324,4],[325,1],[325,3],[157,1],[157,3],[164,1],[326,1],[326,2],[326,2],[159,1],[163,1],[328,1],[328,1],[329,1],[76,1],[76,1],[332,1],[332,2],[332,3],[332,2],[333,2],[333,3],[333,4],[330,1],[330,1],[330,1],[331,1],[331,1],[334,1],[334,1],[313,0],[313,1],[31,1],[32,1],[335,1],[335,1],[336,1],[336,1],[337,2],[338,2],[338,2],[56,2],[56,2],[60,2],[60,2],[60,2],[339,1],[341,1],[340,1],[342,1],[343,0],[343,2],[344,2],[344,2],[345,0],[346,0],[314,3],[314,4],[319,3],[319,3],[21,2],[25,3],[347,1],[348,1],[349,1],[350,1],[351,1],[352,1],[353,1],[354,1],[355,1],[356,1],[357,1],[358,1],[359,1],[360,1],[102,0],[102,1],[102,1],[102,2],[102,2],[104,1],[104,1],[104,2],[104,2],[104,2],[169,4],[170,4],[170,4],[170,5],[170,7],[361,0],[361,1],[365,3],[363,2],[363,3],[363,3],[362,0],[362,2],[364,1],[364,3],[364,2],[366,0],[366,1],[368,5],[368,5],[367,2],[367,6],[367,5],[367,5],[367,5],[367,4],[370,0],[376,0],[377,3],[380,5],[380,4],[380,3],[380,3],[380,2],[369,1],[369,1],[371,0],[371,2],[371,2],[374,2],[374,2],[372,0],[372,3],[372,3],[375,2],[375,3],[375,3],[381,1],[381,1],[320,3],[320,3],[320,3],[317,2],[317,2],[317,2],[321,2],[321,2],[321,2],[321,2],[321,2],[321,2],[318,2],[318,4],[322,2],[322,4],[322,4],[322,3],[322,4],[322,3],[322,4],[322,4],[322,3],[322,4],[322,3],[323,1],[323,1],[382,1],[382,2],[383,1],[383,2],[383,3],[383,3],[383,2],[384,4],[385,2],[385,3],[385,4],[385,4],[385,3],[385,3],[385,4],[385,2],[385,3],[385,2],[385,3],[385,3],[385,4],[385,3],[385,4],[385,4],[385,5],[385,4],[385,3]], +performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) { +/* this == yyval */ + +var $0 = $$.length - 1; +switch (yystate) { +case 2: case 175: +this.$ = $$[$0-2]; +break; +case 3: case 173: case 289: case 292: case 454: case 457: case 543: case 596: case 771: +this.$ = $$[$0-1]; +break; +case 4: + + parser.addCommonTableExpressions($$[$0-3]); + +break; +case 5: case 6: case 17: + + parser.addCommonTableExpressions($$[$0-2]); + +break; +case 12: case 28: case 52: case 128: case 132: case 170: case 180: case 207: case 696: case 698: case 753: case 808: case 883: +this.$ = $$[$0]; +break; +case 14: +this.$ = [$$[$0]]; +break; +case 15: +this.$ = $$[$0-2].concat([$$[$0]]); +break; +case 19: + + parser.addCommonTableExpressions($$[$0-4]); + +break; +case 20: + + parser.addCteAliasLocation(_$[$0-4], $$[$0-4]); + $$[$0-1].alias = $$[$0-4]; + this.$ = $$[$0-1]; + +break; +case 21: + + parser.suggestKeywords(['AS']); + +break; +case 22: case 327: case 774: + + parser.suggestKeywords(['SELECT']); + +break; +case 24: + + this.$ = { tableReferenceList : $$[$0] } + +break; +case 25: case 33: + + parser.suggestTables(); + parser.suggestDatabases({ appendDot: true }); + +break; +case 36: + + this.$ = { valueExpression: $$[$0] }; + +break; +case 37: case 139: + + parser.suggestSelectListAliases(); + +break; +case 38: + + parser.valueExpressionSuggest(); + parser.suggestSelectListAliases(); + parser.suggestGroupBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 39: + + parser.suggestKeywords(['BY']); + parser.suggestGroupBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 49: case 511: case 514: case 515: case 540: case 541: case 562: case 565: + + parser.suggestColumns(); + +break; +case 54: case 55: case 61: case 62: case 539: case 767: case 810: + + parser.valueExpressionSuggest(); + +break; +case 66: + + parser.valueExpressionSuggest(); + parser.suggestAggregateFunctions(); + parser.suggestSelectListAliases(true); + +break; +case 67: + + parser.suggestAggregateFunctions(); + parser.suggestSelectListAliases(true); + +break; +case 71: + + if ($$[$0] && $$[$0].valueExpression) { + this.$ = $$[$0].valueExpression; + } else { + this.$ = {}; + } + this.$.joinType = $$[$0-2]; + if ($$[$0].noJoinCondition) { + this.$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() } + } + if ($$[$0].suggestKeywords) { + this.$.suggestKeywords = $$[$0].suggestKeywords; + } + if (parser.yy.latestTablePrimaries.length > 0) { + parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true; + } + +break; +case 72: + + if ($$[$0] && $$[$0].valueExpression) { + this.$ = $$[$0].valueExpression; + } else { + this.$ = {}; + } + this.$.joinType = $$[$0-3]; + if ($$[$0].noJoinCondition) { + this.$.suggestJoinConditions = { prependOn: true, tablePrimaries: parser.yy.latestTablePrimaries.concat() } + } + if ($$[$0].suggestKeywords) { + this.$.suggestKeywords = $$[$0].suggestKeywords; + } + if (parser.yy.latestTablePrimaries.length > 0) { + parser.yy.latestTablePrimaries[parser.yy.latestTablePrimaries.length - 1].join = true; + } + +break; +case 73: +this.$ = { joinType: $$[$0] }; +break; +case 74: +this.$ = { joinType: $$[$0-1] }; +break; +case 75: + + if ($$[$0-2].suggestKeywords) { + parser.suggestKeywords($$[$0-2].suggestKeywords); + } + +break; +case 76: + + if ($$[$0].suggestKeywords) { + parser.suggestKeywords($$[$0].suggestKeywords); + } + +break; +case 79: + + if (parser.yy.latestTablePrimaries.length > 0) { + var idx = parser.yy.latestTablePrimaries.length - 1; + var tables = []; + do { + var tablePrimary = parser.yy.latestTablePrimaries[idx]; + if (!tablePrimary.subQueryAlias) { + tables.unshift(tablePrimary.alias ? { identifierChain: tablePrimary.identifierChain, alias: tablePrimary.alias } : { identifierChain: tablePrimary.identifierChain }) + } + idx--; + } while (idx >= 0 && tablePrimary.join && !tablePrimary.subQueryAlias) + + if (tables.length > 0) { + parser.suggestJoins({ + prependJoin: false, + joinType: $$[$0-2], + tables: tables + }) + } + } + parser.suggestTables(); + parser.suggestDatabases({ + appendDot: true + }); + +break; +case 84: +this.$ = 'CROSS JOIN'; +break; +case 85: +this.$ = 'FULL JOIN'; +break; +case 86: +this.$ = 'FULL OUTER JOIN'; +break; +case 87: +this.$ = 'INNER JOIN'; +break; +case 88: +this.$ = 'JOIN'; +break; +case 89: +this.$ = 'LEFT INNER JOIN'; +break; +case 90: +this.$ = 'LEFT JOIN'; +break; +case 91: +this.$ = 'LEFT OUTER JOIN'; +break; +case 92: +this.$ = 'LEFT SEMI JOIN'; +break; +case 93: +this.$ = 'OUTER JOIN'; +break; +case 94: case 96: +this.$ = 'RIGHT OUTER JOIN'; +break; +case 95: +this.$ = 'RIGHT JOIN'; +break; +case 97: +this.$ = 'RIGHT SEMI JOIN'; +break; +case 98: +this.$ = 'SEMI JOIN'; +break; +case 99: case 101: case 102: case 104: case 105: case 106: case 107: case 109: case 110: case 111: case 112: +this.$ = { suggestKeywords: ['JOIN'] }; +break; +case 100: case 103: case 108: +this.$ = { suggestKeywords: ['OUTER'] }; +break; +case 113: +this.$ = { noJoinCondition: true, suggestKeywords: ['ON'] }; +break; +case 114: +this.$ = { valueExpression: $$[$0] }; +break; +case 118: + + parser.valueExpressionSuggest(); + parser.suggestJoinConditions({ prependOn: false }); + +break; +case 125: + + parser.suggestKeywords([{ value: '10', weight: 10000 }, { value: '100', weight: 10000 }, { value: '1000', weight: 10000 }, { value: '5000', weight: 10000 }, { value: '10000', weight: 10000 }]) + +break; +case 129: + + if ($$[$0].emptyOrderBy) { + parser.suggestOrderBys({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + +break; +case 130: + + parser.suggestKeywords(['BY']); + parser.suggestOrderBys({ prefix: 'BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 134: + + this.$ = { emptyOrderBy: false } + parser.valueExpressionSuggest(); + parser.suggestAnalyticFunctions(); + parser.suggestSelectListAliases(); + +break; +case 135: case 136: case 137: +this.$ = { emptyOrderBy: false }; +break; +case 138: +this.$ = parser.mergeSuggestKeywords($$[$0]); +break; +case 140: + + this.$ = { emptyOrderBy: true } + parser.valueExpressionSuggest(); + parser.suggestAnalyticFunctions(); + parser.suggestSelectListAliases(); + +break; +case 141: +this.$ = { suggestKeywords: ['ASC', 'DESC'] };; +break; +case 144: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2]), _$[$0]); + this.$ = { selectList: $$[$0] }; + +break; +case 145: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + this.$ = { selectList: $$[$0-1], tableExpression: $$[$0] } + +break; +case 146: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2]), _$[$0]); + if ($$[$0].cursorAtStart) { + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-1]) { + keywords = keywords.concat(parser.SELECT_FIRST_OPTIONAL_KEYWORDS); + } + parser.suggestKeywords(keywords); + } else { + parser.checkForSelectListKeywords($$[$0]); + } + if ($$[$0].suggestFunctions) { + parser.suggestFunctions(); + } + if ($$[$0].suggestColumns) { + parser.suggestColumns({ identifierChain: [], source: 'select' }); + } + if ($$[$0].suggestTables) { + parser.suggestTables({ prependQuestionMark: true, prependFrom: true }); + } + if ($$[$0].suggestDatabases) { + parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true }); + } + if ($$[$0].suggestAggregateFunctions && (!$$[$0-1] || $$[$0-1] === 'ALL')) { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + +break; +case 147: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2]), _$[$0], true); + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-1] || $$[$0-1] === 'ALL') { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + if (!$$[$0-1]) { + keywords = keywords.concat(parser.SELECT_FIRST_OPTIONAL_KEYWORDS); + } + parser.suggestKeywords(keywords); + parser.suggestFunctions(); + parser.suggestColumns({ identifierChain: [], source: 'select' }); + parser.suggestTables({ prependQuestionMark: true, prependFrom: true }); + parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true }); + +break; +case 148: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + +break; +case 149: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + parser.selectListNoTableSuggest($$[$0-1], $$[$0-2]); + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'select'; + } + +break; +case 150: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1], true); + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-2] || $$[$0-2] === 'ALL') { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + if (!$$[$0-2]) { + keywords = keywords.concat(parser.SELECT_FIRST_OPTIONAL_KEYWORDS); + } + parser.suggestKeywords(keywords); + parser.suggestFunctions(); + parser.suggestColumns({ identifierChain: [], source: 'select' }); + parser.suggestTables({ prependQuestionMark: true, prependFrom: true }); + parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true }); + +break; +case 151: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]), _$[$0-2]); + parser.checkForSelectListKeywords($$[$0-2]); + +break; +case 152: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5]), _$[$0-3]); + parser.checkForSelectListKeywords($$[$0-3]); + +break; +case 153: + + parser.addClauseLocation('selectList', parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3]), _$[$0-1]); + parser.checkForSelectListKeywords($$[$0-1]); + var keywords = ['FROM']; + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + parser.suggestTables({ prependFrom: true }); + parser.suggestDatabases({ prependFrom: true, appendDot: true }); + +break; +case 157: case 158: + + parser.addClauseLocation('whereClause', _$[$0-1], $$[$0].whereClauseLocation); + parser.addClauseLocation('limitClause', $$[$0].limitClausePreceding || _$[$0-1], $$[$0].limitClauseLocation); + +break; +case 159: + + var keywords = []; + + parser.addClauseLocation('whereClause', _$[$0-3], $$[$0-1].whereClauseLocation); + parser.addClauseLocation('limitClause', $$[$0-2].limitClausePreceding || _$[$0-3], $$[$0-2].limitClauseLocation); + + if ($$[$0-3]) { + if (typeof $$[$0-3].tableReferenceList.hasJoinCondition !== 'undefined' && !$$[$0-3].tableReferenceList.hasJoinCondition) { + keywords.push({ value: 'ON', weight: 3 }); + } + if ($$[$0-3].suggestKeywords) { + keywords = parser.createWeightedKeywords($$[$0-3].suggestKeywords, 3); + } + if ($$[$0-3].tableReferenceList.suggestJoinConditions) { + parser.suggestJoinConditions($$[$0-3].tableReferenceList.suggestJoinConditions); + } + if ($$[$0-3].tableReferenceList.suggestJoins) { + parser.suggestJoins($$[$0-3].tableReferenceList.suggestJoins); + } + if ($$[$0-3].tableReferenceList.suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-3].tableReferenceList.suggestKeywords, 3)); + } + + // Lower the weights for 'TABLESAMPLE' + keywords.forEach(function (keyword) { + if (keyword.value === 'TABLESAMPLE') { + keyword.weight = 1.1; + } + }); + + if ($$[$0-3].tableReferenceList.types) { + var veKeywords = parser.getValueExpressionKeywords($$[$0-3].tableReferenceList); + keywords = keywords.concat(veKeywords.suggestKeywords); + if (veKeywords.suggestColRefKeywords) { + parser.suggestColRefKeywords(veKeywords.suggestColRefKeywords); + parser.addColRefIfExists($$[$0-3].tableReferenceList); + } + } + } + + if ($$[$0-1].empty && $$[$0] && $$[$0].joinType.toUpperCase() === 'JOIN') { + keywords = keywords.concat(['FULL', 'FULL OUTER', 'INNER', 'LEFT', 'LEFT OUTER', 'RIGHT', 'RIGHT OUTER']); + parser.suggestKeywords(keywords); + return; + } + + if ($$[$0-1].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2)); + } + + if ($$[$0-1].suggestFilters) { + parser.suggestFilters($$[$0-1].suggestFilters); + } + if ($$[$0-1].suggestGroupBys) { + parser.suggestGroupBys($$[$0-1].suggestGroupBys); + } + if ($$[$0-1].suggestOrderBys) { + parser.suggestOrderBys($$[$0-1].suggestOrderBys); + } + + if ($$[$0-1].empty) { + keywords.push({ value: 'UNION', weight: 2.11 }); + } + + keywords = keywords.concat([ + { value: 'FULL JOIN', weight: 1 }, + { value: 'FULL OUTER JOIN', weight: 1 }, + { value: 'INNER JOIN', weight: 1 }, + { value: 'JOIN', weight: 1 }, + { value: 'LEFT JOIN', weight: 1 }, + { value: 'LEFT OUTER JOIN', weight: 1 }, + { value: 'RIGHT JOIN', weight: 1 }, + { value: 'RIGHT OUTER JOIN', weight: 1 } + ]); + parser.suggestKeywords(keywords); + +break; +case 160: + + // A couple of things are going on here: + // - If there are no SelectConditions (WHERE, GROUP BY, etc.) we should suggest complete join options + // - If there's an OptionalJoin at the end, i.e. 'SELECT * FROM foo | JOIN ...' we should suggest + // different join types + // - The FromClause could end with a valueExpression, in which case we should suggest keywords like '=' + // or 'AND' based on type + + if (!$$[$0-1]) { + parser.addClauseLocation('whereClause', _$[$0-2]); + parser.addClauseLocation('limitClause', _$[$0-2]); + return; + } + parser.addClauseLocation('whereClause', _$[$0-2], $$[$0-1].whereClauseLocation); + parser.addClauseLocation('limitClause', $$[$0-1].limitClausePreceding || _$[$0-2], $$[$0-1].limitClauseLocation); + var keywords = []; + + if ($$[$0-1].suggestColRefKeywords) { + parser.suggestColRefKeywords($$[$0-1].suggestColRefKeywords); + parser.addColRefIfExists($$[$0-1]); + } + + if ($$[$0-1].suggestKeywords && $$[$0-1].suggestKeywords.length) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-1].suggestKeywords, 2)); + } + + if ($$[$0-1].cursorAtEnd) { + keywords.push({ value: 'UNION', weight: 2.11 }); + } + parser.suggestKeywords(keywords); + +break; +case 161: +this.$ = [ $$[$0] ]; +break; +case 162: + + $$[$0-2].push($$[$0]); + +break; +case 164: case 165: + + this.$ = { cursorAtStart : true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true }; + +break; +case 167: + + parser.checkForSelectListKeywords($$[$0-2]); + +break; +case 168: + + parser.checkForSelectListKeywords($$[$0-3]); + +break; +case 169: + + this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestTables: true, suggestDatabases: true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true }; + +break; +case 171: case 172: case 174: + + this.$ = { suggestKeywords: parser.getSelectListKeywords(), suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true, }; + +break; +case 176: + + if ($$[$0]) { + parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0-1]); + this.$ = { valueExpression: $$[$0-1], alias: $$[$0].alias }; + if (!parser.yy.selectListAliases) { + parser.yy.selectListAliases = []; + } + parser.yy.selectListAliases.push($$[$0-1].function && $$[$0-1].types && $$[$0-1].types.length && $$[$0-1].types[0] === 'UDFREF' ? { name: $$[$0].alias, udfRef: $$[$0-1].function, types: $$[$0-1].types } : { name: $$[$0].alias, types: $$[$0-1].types || ['T'] }); + } else { + this.$ = { valueExpression: $$[$0-1] } + } + +break; +case 177: + + parser.addAsteriskLocation(_$[$0], [{ asterisk: true }]); + this.$ = { asterisk: true } + +break; +case 178: + + if ($$[$0]) { + parser.addColumnAliasLocation($$[$0].location, $$[$0].alias, _$[$0-1]); + } + +break; +case 179: + + parser.suggestFunctions(); + parser.suggestColumns(); + parser.addColumnAliasLocation(_$[$0], $$[$0], _$[$0-2]); + this.$ = { suggestAggregateFunctions: true }; + +break; +case 181: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], + [{ value: 'WHERE', weight: 7 }, { value: 'GROUP BY', weight: 6 }, { value: 'HAVING', weight: 5 }, { value: 'ORDER BY', weight: 4 }, { value: 'LIMIT', weight: 3 }], + [true, true, true, true, true]); + + if (keywords.length > 0) { + this.$ = { suggestKeywords: keywords, empty: !$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0] }; + } else { + this.$ = {}; + } + + this.$.whereClauseLocation = $$[$0-4] ? _$[$0-4] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + + if (!$$[$0-4] && !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) { + this.$.suggestFilters = { prefix: 'WHERE', tablePrimaries: parser.yy.latestTablePrimaries.concat() }; + } + if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]) { + this.$.suggestGroupBys = { prefix: 'GROUP BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }; + } + if (!$$[$0-1] && !$$[$0]) { + this.$.suggestOrderBys = { prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }; + } + +break; +case 182: + + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'where'; + } + +break; +case 183: + + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'group by'; + } + +break; +case 185: + + if (parser.yy.result.suggestColumns) { + parser.yy.result.suggestColumns.source = 'order by'; + } + +break; +case 187: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-3], $$[$0-2], $$[$0-1], $$[$0]], + [{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], + [true, true, true, true]); + if ($$[$0-5].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-5].suggestKeywords, 1)); + } + this.$ = parser.getValueExpressionKeywords($$[$0-5], keywords); + this.$.cursorAtEnd = !$$[$0-3] && !$$[$0-2] && !$$[$0-1] && !$$[$0]; + if ($$[$0-5].columnReference) { + this.$.columnReference = $$[$0-5].columnReference; + } + if (!$$[$0-3]) { + parser.suggestGroupBys({ prefix: 'GROUP BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + if (!$$[$0-3] && !$$[$0-2] && !$$[$0-1]) { + parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-5], _$[$0-5]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 188: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-2], $$[$0-1], $$[$0]], + [{ value: 'HAVING', weight: 7 }, { value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], + [true, true, true]); + if ($$[$0-4].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-4].suggestKeywords, 8)); + } + if ($$[$0-4].valueExpression) { + this.$ = parser.getValueExpressionKeywords($$[$0-4].valueExpression, keywords); + if ($$[$0-4].valueExpression.columnReference) { + this.$.columnReference = $$[$0-4].valueExpression.columnReference; + } + } else { + this.$ = { suggestKeywords: keywords }; + } + this.$.cursorAtEnd = !$$[$0-2] && !$$[$0-1] && !$$[$0]; + if (!$$[$0-2] && !$$[$0-1]) { + parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-2], _$[$0-2], $$[$0-4], _$[$0-4]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 189: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0-1], $$[$0]], + [{ value: 'ORDER BY', weight: 5 }, { value: 'LIMIT', weight: 3 }], + [true, true]); + this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0-1] && !$$[$0] }; + if (!$$[$0-1]) { + parser.suggestOrderBys({ prefix: 'ORDER BY', tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-1], _$[$0-1], $$[$0-3], _$[$0-3]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 190: + + var keywords = parser.getKeywordsForOptionalsLR( + [$$[$0]], + [{ value: 'LIMIT', weight: 3 }], + [true]); + if ($$[$0-2].suggestKeywords) { + keywords = keywords.concat(parser.createWeightedKeywords($$[$0-2].suggestKeywords, 4)); + } + this.$ = { suggestKeywords: keywords, cursorAtEnd: !$$[$0] }; + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2]); + this.$.limitClauseLocation = $$[$0] ? _$[$0] : undefined; + +break; +case 191: + + this.$ = { suggestKeywords: [], cursorAtEnd: true }; + this.$.whereClauseLocation = $$[$0-5] ? _$[$0-5] : undefined; + this.$.limitClausePreceding = parser.firstDefined($$[$0-2], _$[$0-2], $$[$0-3], _$[$0-3], $$[$0-4], _$[$0-4], $$[$0-5], _$[$0-5]); + this.$.limitClauseLocation = _$[$0-1]; + +break; +case 202: + + parser.suggestKeywords(['ALL', 'DISTINCT', 'SELECT']); + +break; +case 203: + + parser.suggestKeywords(['ALL', 'DISTINCT']); + +break; +case 208: + + if ($$[$0].suggestFilters) { + parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + } + +break; +case 209: + + parser.suggestFunctions(); + parser.suggestColumns(); + parser.suggestKeywords(['EXISTS', 'NOT EXISTS']); + parser.suggestFilters({ tablePrimaries: parser.yy.latestTablePrimaries.concat() }); + +break; +case 212: + + if (!$$[$0]) { + $$[$0-1].suggestKeywords = ['OVER']; + } + +break; +case 219: + + parser.suggestKeywords(['OVER']); + +break; +case 228: + + this.$ = { function: $$[$0-3], types: ['UDFREF'] }; + +break; +case 229: case 247: + + parser.addFunctionArgumentLocations($$[$0-4], $$[$0-1].expressions); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 230: + + parser.valueExpressionSuggest(); + var keywords = parser.getSelectListKeywords(true); + if (!$$[$0-2]) { + if ($$[$0-4].toLowerCase() === 'group_concat') { + keywords.push('ALL'); + } else { + keywords.push('DISTINCT'); + } + } + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + parser.applyArgumentTypesToSuggestions($$[$0-4], 1); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 231: case 245: + + parser.suggestValueExpressionKeywords($$[$0-2].expressions[$$[$0-2].expressions.length - 1].expression); + this.$ = { function: $$[$0-5], types: ['UDFREF'] }; + +break; +case 232: + + if ($$[$0-1].cursorAtStart) { + var keywords = parser.getSelectListKeywords(true); + if (!$$[$0-2]) { + if ($$[$0-4].toLowerCase() === 'group_concat') { + keywords.push('ALL'); + } else { + keywords.push('DISTINCT'); + } + } + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + } + if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) { + parser.applyArgumentTypesToSuggestions($$[$0-4], $$[$0-1].activePosition); + } + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 241: + + parser.addFunctionArgumentLocations($$[$0-3], [{ + expression: { text: $$[$0-1] }, + location: _$[$0-1] + }]); + this.$ = { function: $$[$0-3], types: ['UDFREF'] } + +break; +case 242: case 248: + + this.$ = { function: $$[$0-2], types: ['UDFREF'] } + +break; +case 243: + + parser.addFunctionArgumentLocations($$[$0-4], $$[$0-1].expressions); + this.$ = { function: $$[$0-4], types: ['UDFREF'] } + +break; +case 244: + + parser.valueExpressionSuggest(); + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-2]) { + keywords.push('DISTINCT'); + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + } + parser.suggestKeywords(keywords); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 246: + + if ($$[$0-1].cursorAtStart) { + var keywords = parser.getSelectListKeywords(); + if (!$$[$0-2]) { + keywords.push('DISTINCT'); + } + parser.suggestKeywords(keywords); + } + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 249: + + parser.valueExpressionSuggest(); + parser.applyArgumentTypesToSuggestions($$[$0-4], 1); + var keywords = parser.getSelectListKeywords(true); + if (!$$[$0-2]) { + keywords.push('DISTINCT'); + } + if (parser.yy.result.suggestKeywords) { + keywords = parser.yy.result.suggestKeywords.concat(keywords); + } + parser.suggestKeywords(keywords); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 250: + + parser.suggestValueExpressionKeywords($$[$0-2]); + this.$ = { function: $$[$0-5], types: ['UDFREF'] }; + +break; +case 251: + + if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) { + parser.applyArgumentTypesToSuggestions($$[$0-4], 1); + } + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 252: + + this.$ = { function: $$[$0-2], types: ['UDFREF'] } + +break; +case 253: + + parser.addFunctionArgumentLocations($$[$0-3], $$[$0-1].expressions); + this.$ = { + function: $$[$0-3], + expression: $$[$0-1].expressions[$$[$0-1].expressions.length - 1].expression, + types: ['UDFREF'] + } + +break; +case 254: + + parser.valueExpressionSuggest(); + parser.applyArgumentTypesToSuggestions($$[$0-3], 1); + this.$ = { function: $$[$0-3], types: ['UDFREF'] }; + +break; +case 255: + + parser.addFunctionArgumentLocations($$[$0-4], $$[$0-2].expressions); + parser.suggestValueExpressionKeywords($$[$0-2].expressions[$$[$0-2].expressions.length - 1].expression); + this.$ = { function: $$[$0-4], types: ['UDFREF'] }; + +break; +case 256: + + parser.addFunctionArgumentLocations($$[$0-3], $$[$0-1].expressions); + parser.applyArgumentTypesToSuggestions($$[$0-3], $$[$0-1].activePosition); + this.$ = { function: $$[$0-3], types: ['UDFREF'] }; + +break; +case 261: + + var expression = $$[$0-3]; + parser.extractExpressionText(expression, $$[$0-3], $$[$0-2], $$[$0-1]); + parser.addFunctionArgumentLocations($$[$0-5], [{ + expression: expression, + location: { + first_line: _$[$0-3].first_line, + last_line: _$[$0-1].last_line, + first_column: _$[$0-3].first_column, + last_column: _$[$0-1].last_column + } + }]); + this.$ = { types: [ $$[$0-1].toUpperCase() ] } + +break; +case 262: case 267: case 268: case 702: +this.$ = { types: [ 'T' ] }; +break; +case 263: + + parser.valueExpressionSuggest(); + this.$ = { types: [ $$[$0-1].toUpperCase() ] }; + +break; +case 264: case 265: + + parser.valueExpressionSuggest(); + this.$ = { types: [ 'T' ] }; + +break; +case 266: +this.$ = { types: [ $$[$0-1].toUpperCase() ] }; +break; +case 269: + + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'AS', weight: 2 }]); + this.$ = { types: [ $$[$0-1].toUpperCase() ] }; + +break; +case 270: + + parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'AS', weight: 2 }]); + this.$ = { types: [ 'T' ] }; + +break; +case 271: case 272: + + parser.suggestKeywords(parser.getTypeKeywords()); + this.$ = { types: [ 'T' ] }; + +break; +case 273: + + // We need to handle arbitrary UDFs here instead of inside UserDefinedFunction or there will be a conflict + // with columnReference for functions like: db.udf(foo) + var fn = $$[$0-1].chain[$$[$0-1].chain.length - 1].name.toLowerCase(); + parser.addFunctionArgumentLocations(fn, $$[$0].expressions, $$[$0-1].chain); + if ($$[$0-1].lastLoc && $$[$0-1].lastLoc.location) { + $$[$0-1].lastLoc.type = 'function'; + $$[$0-1].lastLoc.function = fn; + $$[$0-1].lastLoc.location = { + first_line: $$[$0-1].lastLoc.location.first_line, + last_line: $$[$0-1].lastLoc.location.last_line, + first_column: $$[$0-1].lastLoc.location.first_column, + last_column: $$[$0-1].lastLoc.location.last_column - 1 + } + if ($$[$0-1].lastLoc !== $$[$0-1].firstLoc) { + $$[$0-1].firstLoc.type = 'database'; + } else { + delete $$[$0-1].lastLoc.identifierChain; + } + } + if ($$[$0].expressions && $$[$0].expressions.length) { + this.$ = { function: fn, expression: $$[$0].expressions[$$[$0].expressions.length - 1].expression, types: ['UDFREF'] } + } else { + this.$ = { function: fn, types: ['UDFREF'] } + } + +break; +case 274: + + parser.addFunctionLocation(_$[$0-1], $$[$0-1]); + if ($$[$0].expressions && $$[$0].expressions.length) { + this.$ = { function: $$[$0-1], expression: $$[$0].expressions[$$[$0].expressions.length - 1].expression, types: ['UDFREF'] } + } else { + this.$ = { function: $$[$0-1], types: ['UDFREF'] } + } + +break; +case 277: +this.$ = { types: ['COLREF'], columnReference: $$[$0].chain }; +break; +case 278: +this.$ = { types: [ 'NULL' ], text: $$[$0] }; +break; +case 279: + + var fn = $$[$0-1].chain[$$[$0-1].chain.length - 1].name.toLowerCase(); + parser.addFunctionArgumentLocations(fn, $$[$0].expressions, $$[$0-1].chain); + $$[$0-1].lastLoc.type = 'function'; + $$[$0-1].lastLoc.function = fn; + $$[$0-1].lastLoc.location = { + first_line: $$[$0-1].lastLoc.location.first_line, + last_line: $$[$0-1].lastLoc.location.last_line, + first_column: $$[$0-1].lastLoc.location.first_column, + last_column: $$[$0-1].lastLoc.location.last_column - 1 + } + if ($$[$0-1].lastLoc !== $$[$0-1].firstLoc) { + $$[$0-1].firstLoc.type = 'database'; + } else { + delete $$[$0-1].lastLoc.identifierChain; + } + if ($$[$0].activePosition) { + parser.applyArgumentTypesToSuggestions(fn, $$[$0].activePosition); + } + this.$ = { function: fn, types: ['UDFREF'] }; + +break; +case 280: case 286: case 287: + + parser.addFunctionLocation(_$[$0-1], $$[$0-1]); + parser.addFunctionArgumentLocations($$[$0-1], $$[$0].expressions); + if ($$[$0].activePosition) { + parser.applyArgumentTypesToSuggestions($$[$0-1], $$[$0].activePosition); + } + this.$ = { function: $$[$0-1], types: ['UDFREF'] }; + +break; +case 283: + + if ($$[$0].suggestKeywords) { + this.$ = { types: ['COLREF'], columnReference: $$[$0], suggestKeywords: $$[$0].suggestKeywords }; + } else { + this.$ = { types: ['COLREF'], columnReference: $$[$0] }; + } + +break; +case 284: case 285: + + parser.addFunctionLocation(_$[$0-1], $$[$0-1]); + parser.addFunctionArgumentLocations($$[$0-1], $$[$0].expressions); + if ($$[$0].expressions && $$[$0].expressions.length) { + this.$ = { function: $$[$0-1], expression: $$[$0].expressions[$$[$0].expressions.length - 1].expression, types: ['UDFREF'] } + } else { + this.$ = { function: $$[$0-1], types: ['UDFREF'] } + } + +break; +case 290: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: 1, + expressions: [{ expression: { text: '' }, location: _$[$0-1] }] + } + +break; +case 291: + + parser.suggestValueExpressionKeywords($$[$0-2].expressions[$$[$0-2].expressions.length - 1].expression); + this.$ = $$[$0-3]; + +break; +case 293: case 295: + + this.$ = { + activePosition: 1, + expressions: [{ expression: $$[$0], location: _$[$0] }] + } + +break; +case 294: case 296: + + this.$ = { + activePosition: $$[$0-2].activePosition + 1, + expressions: $$[$0-2].expressions.concat([{ expression: $$[$0], location: _$[$0] }]) + } + +break; +case 297: + + this.$ = { + activePosition: 1, + expressions: [{ expression: $$[$0-2], location: _$[$0-2] }].concat($$[$0].expressions) + } + +break; +case 298: + + this.$ = { + activePosition: $$[$0-4].activePosition + 1, + expressions: $$[$0-4].expressions.concat([{ expression: $$[$0-2], location: _$[$0-2] }]).concat($$[$0].expressions) + } + +break; +case 299: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: $$[$0-2].activePosition + 1, + expressions: $$[$0-2].expressions.concat([{ expression: { text: '' }, location: _$[$0] }]) + } + +break; +case 300: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: $$[$0-4].activePosition + 1, + expressions: $$[$0-4].expressions.concat([{ expression: { text: '' }, location: _$[$0-2] }]).concat($$[$0].expressions) + } + +break; +case 301: + + parser.suggestValueExpressionKeywords($$[$0-3].expressions[$$[$0-3].expressions.length - 1].expression); + this.$ = { + activePosition: $$[$0-3].activePosition, + expressions: $$[$0-3].expressions.concat($$[$0].expressions) + } + +break; +case 302: + + parser.valueExpressionSuggest(); + this.$ = { + cursorAtStart : true, + activePosition: 1, + expressions: [{ expression: { text: '' }, location: _$[$0-2] }].concat($$[$0].expressions) + }; + +break; +case 303: + + parser.valueExpressionSuggest(); + this.$ = { + cursorAtStart : true, + activePosition: 1, + expressions: [{ expression: { text: '' }, location: _$[$0-1] }, { expression: { text: '' }, location: _$[$0] }] + }; + +break; +case 304: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: 2, + expressions: [{ expression: { text: '' }, location: _$[$0-1] }, { expression: { text: '' }, location: _$[$0] }] + }; + +break; +case 305: + + parser.valueExpressionSuggest(); + this.$ = { + activePosition: 2, + expressions: [{ expression: { text: '' }, location: _$[$0-3] }, { expression: { text: '' }, location: _$[$0-2] }].concat($$[$0].expressions) + }; + +break; +case 313: case 314: + + return parser.yy.result; + +break; +case 315: + + parser.prepareNewStatement(); + +break; +case 317: case 319: case 321: + + parser.addStatementLocation(_$[$0]); + +break; +case 320: case 322: + + parser.addStatementLocation(_$[$0-3]); + +break; +case 326: + + parser.suggestDdlAndDmlKeywords(); + +break; +case 455: case 458: case 544: +this.$ = ''; +break; +case 470: case 473: + + parser.yy.correlatedSubQuery = false; + +break; +case 471: case 475: + + parser.suggestKeywords(['EXISTS']); + +break; +case 474: + + parser.suggestKeywords(['NOT EXISTS']); + +break; +case 485: case 487: case 488: case 490: + + parser.suggestKeywords(['<', '<=', '<>', '=', '>', '>=']); + +break; +case 486: case 489: + + parser.suggestKeywords(['VALUES']); + +break; +case 519: case 545: + + parser.addTableLocation(_$[$0], [ { name: $$[$0] } ]); + this.$ = { identifierChain: [ { name: $$[$0] } ] }; + +break; +case 520: case 546: + + parser.addDatabaseLocation(_$[$0-2], [ { name: $$[$0-2] } ]); + parser.addTableLocation(_$[$0], [ { name: $$[$0-2] }, { name: $$[$0] } ]); + this.$ = { identifierChain: [ { name: $$[$0-2] }, { name: $$[$0] } ] }; + +break; +case 521: + + parser.suggestTables(); + parser.suggestDatabases({ appendDot: true }); + +break; +case 522: case 527: + + parser.suggestDatabases(); + this.$ = { identifierChain: [{ name: $$[$0-2] }] }; + +break; +case 523: case 548: + + parser.suggestTablesOrColumns($$[$0-2]); + +break; +case 524: +this.$ = [{ name: $$[$0] }]; +break; +case 525: +this.$ = [{ name: $$[$0-2] }, { name: $$[$0-1] }]; +break; +case 526: + + parser.suggestDatabases({ appendDot: true }); + +break; +case 530: + + parser.suggestDatabases(); + +break; +case 547: + + parser.suggestTables(); + parser.suggestDatabases({ prependDot: true }); + +break; +case 550: +this.$ = { identifierChain: $$[$0-1].identifierChain, alias: $$[$0] }; +break; +case 553: + + parser.yy.locations[parser.yy.locations.length - 1].type = 'column'; + +break; +case 554: case 719: + + parser.addAsteriskLocation(_$[$0], $$[$0-2].concat({ asterisk: true })); + +break; +case 556: + + this.$ = [ $$[$0].identifier ]; + parser.yy.firstChainLocation = parser.addUnknownLocation($$[$0].location, [ $$[$0].identifier ]); + +break; +case 557: + + if (parser.yy.firstChainLocation) { + parser.yy.firstChainLocation.firstInChain = true; + delete parser.yy.firstChainLocation; + } + $$[$0-2].push($$[$0].identifier); + parser.addUnknownLocation($$[$0].location, $$[$0-2].concat()); + +break; +case 558: + + parser.suggestColumns({ + identifierChain: $$[$0-2] + }); + this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] }; + +break; +case 559: + + parser.suggestColumns({ + identifierChain: $$[$0-4] + }); + this.$ = { suggestKeywords: [{ value: '*', weight: 10000 }] }; + +break; +case 560: +this.$ = [ $$[$0].identifier ]; +break; +case 561: + + $$[$0-2].push($$[$0].identifier); + +break; +case 563: + + parser.suggestColumns({ identifierChain: $$[$0-2] }); + +break; +case 564: + + parser.suggestColumns({ identifierChain: $$[$0-4] }); + +break; +case 566: +this.$ = { identifier: { name: $$[$0] }, location: _$[$0] }; +break; +case 587: case 588: + + // verifyType($$[$0], 'BOOLEAN'); + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 589: case 614: + + this.$ = $$[$0]; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 590: + + // verifyType($$[$0], 'NUMBER'); + this.$ = $$[$0]; + $$[$0].types = ['NUMBER']; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 591: case 592: case 593: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 594: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 595: + + this.$ = { types: [ 'BOOLEAN' ] }; + // clear correlated flag after completed sub-query (set by lexer) + parser.yy.correlatedSubQuery = false; + +break; +case 597: case 598: case 599: case 600: + + parser.addColRefToVariableIfExists($$[$0-2], $$[$0]); + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 601: case 602: case 603: case 604: case 634: case 692: case 693: +this.$ = { types: [ 'BOOLEAN' ] }; +break; +case 605: + + this.$ = { types: [ 'BOOLEAN' ] } + parser.extractExpressionText(this.$, $$[$0-5], $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 606: + + this.$ = { types: [ 'BOOLEAN' ] } + parser.extractExpressionText(this.$, $$[$0-4], $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 607: case 608: + + // verifyType($$[$0-2], 'BOOLEAN'); + // verifyType($$[$0], 'BOOLEAN'); + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 609: case 610: case 611: + + // verifyType($$[$0-2], 'NUMBER'); + // verifyType($$[$0], 'NUMBER'); + this.$ = { types: [ 'NUMBER' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 612: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 613: + + this.$ = { types: [ 'BOOLEAN' ] }; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 615: + + this.$ = $$[$0]; + parser.extractExpressionText(this.$, $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 617: + + parser.suggestKeywords(['BETWEEN', 'EXISTS', 'IN', 'LIKE', 'REGEXP', 'RLIKE']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 618: case 620: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }; +break; +case 619: + + parser.suggestFunctions(); + parser.suggestColumns(); + parser.suggestKeywords(['EXISTS']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 621: + + parser.suggestFunctions({ types: [ 'BOOLEAN' ] }); + parser.suggestColumns({ types: [ 'BOOLEAN' ] }); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 622: +this.$ = { types: [ 'T' ], suggestFilters: $$[$0].suggestFilters }; +break; +case 623: + + parser.suggestFunctions(); + parser.suggestColumns(); + this.$ = { types: [ 'T' ] }; + +break; +case 624: + + if (!$$[$0].typeSet) { + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + } + this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 625: + + parser.suggestFunctions({ types: [ 'NUMBER' ] }); + parser.suggestColumns({ types: [ 'NUMBER' ] }); + this.$ = { types: [ 'NUMBER' ] }; + +break; +case 626: + + parser.suggestKeywords(['FALSE', 'NOT NULL', 'NOT TRUE', 'NOT FALSE', 'NULL', 'TRUE']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 627: + + parser.suggestKeywords(['FALSE', 'NULL', 'TRUE']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 628: + + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 629: case 630: case 631: + + parser.suggestKeywords(['NOT']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 632: + + parser.valueExpressionSuggest($$[$0-5], $$[$0-3] ? 'IS NOT DISTINCT FROM' : 'IS DISTINCT FROM'); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 633: + + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters } + +break; +case 635: + + this.$ = $$[$0-1]; + +break; +case 636: + + parser.valueExpressionSuggest(); + this.$ = { types: ['T'], typeSet: true }; + +break; +case 637: + + parser.valueExpressionSuggest($$[$0], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 638: case 639: case 640: + + parser.valueExpressionSuggest($$[$0], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 641: case 642: case 643: case 644: + + if (!$$[$0-2].typeSet) { + parser.applyTypeToSuggestions($$[$0]); + parser.addColRefIfExists($$[$0]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters } + +break; +case 645: case 647: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 646: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ] , typeSet: true, endsWithLessThanOrEqual: true }; + +break; +case 648: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true, endsWithLessThanOrEqual: $$[$0-1] === '<=' }; + +break; +case 649: case 650: case 651: case 652: + + if (!$$[$0].typeSet) { + parser.applyTypeToSuggestions($$[$0-2]); + parser.addColRefIfExists($$[$0-2]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters } + +break; +case 653: + + if ($$[$0].inValueEdit) { + parser.valueExpressionSuggest($$[$0-3], $$[$0-2] + ' ' + $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-3]); + } + if ($$[$0].cursorAtStart) { + parser.suggestKeywords(['SELECT']); + } + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 654: + + if ($$[$0].inValueEdit) { + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + } + if ($$[$0].cursorAtStart) { + parser.suggestKeywords(['SELECT']); + } + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 655: case 656: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-5].suggestFilters }; +break; +case 657: case 658: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-4].suggestFilters }; +break; +case 659: + + if ($$[$0-2].types[0] === $$[$0].types[0] && !$$[$0-5].typeSet) { + parser.applyTypeToSuggestions($$[$0-2]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-5].suggestFilters }; + +break; +case 660: + + if ($$[$0-5].types[0] === $$[$0].types[0] && !$$[$0-2].typeSet) { + parser.applyTypeToSuggestions($$[$0-5]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }; + +break; +case 661: + + if ($$[$0-5].types[0] === $$[$0-2].types[0] && !$$[$0].typeSet) { + parser.applyTypeToSuggestions($$[$0-5]); + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 662: + + parser.valueExpressionSuggest($$[$0-5], $$[$0-1]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 663: case 669: + + parser.suggestValueExpressionKeywords($$[$0-1], ['AND']); + this.$ = { types: [ 'BOOLEAN' ] }; + +break; +case 664: + + parser.valueExpressionSuggest($$[$0-3], $$[$0-2] + ' ' + $$[$0-1]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 665: + + if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0-4].typeSet) { + parser.applyTypeToSuggestions($$[$0-4]) + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-4].suggestFilters }; + +break; +case 666: + + if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0-2].typeSet) { + parser.applyTypeToSuggestions($$[$0-4]) + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }; + +break; +case 667: + + if ($$[$0-4].types[0] === $$[$0-2].types[0] && !$$[$0].typeSet) { + parser.applyTypeToSuggestions($$[$0-4]) + } + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 668: + + parser.valueExpressionSuggest($$[$0-4], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-4]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 670: + + parser.valueExpressionSuggest($$[$0-2], $$[$0-1]); + parser.applyTypeToSuggestions($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 671: case 673: case 675: case 677: + + parser.valueExpressionSuggest(undefined, $$[$0-1]); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true, suggestFilters: true }; + +break; +case 672: case 676: + + parser.addColRefIfExists($$[$0]); + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters } + +break; +case 674: case 678: + + parser.addColRefIfExists($$[$0-2]); + this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0].suggestFilters } + +break; +case 679: case 680: + + parser.valueExpressionSuggest(undefined, $$[$0-1]); + parser.applyTypeToSuggestions({ types: [ 'NUMBER' ] }); + this.$ = { types: [ 'NUMBER' ], typeSet: true }; + +break; +case 681: case 682: case 683: + + if (!$$[$0-2].typeSet) { + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + parser.addColRefIfExists($$[$0]); + } + this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0-2].suggestFilters } + +break; +case 684: case 685: case 686: + + parser.valueExpressionSuggest(undefined, $$[$0-1]); + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + this.$ = { types: [ 'NUMBER' ], typeSet: true }; + +break; +case 687: case 688: case 689: + + if (!$$[$0].typeSet) { + parser.applyTypeToSuggestions({ types: ['NUMBER'] }); + parser.addColRefIfExists($$[$0-2]); + } + this.$ = { types: [ 'NUMBER' ], suggestFilters: $$[$0].suggestFilters }; + +break; +case 690: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-1].suggestFilters }; +break; +case 691: +this.$ = { types: [ 'BOOLEAN' ], suggestFilters: $$[$0-2].suggestFilters }; +break; +case 694: + + parser.valueExpressionSuggest(undefined, $$[$0]); + parser.applyTypeToSuggestions({ types: [ 'STRING' ] }); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 695: + + parser.valueExpressionSuggest(undefined, $$[$0-1] + ' ' + $$[$0]); + parser.applyTypeToSuggestions({ types: [ 'STRING' ] }); + this.$ = { types: [ 'BOOLEAN' ], typeSet: true }; + +break; +case 697: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { types: [ 'T' ], typeSet: true }; + +break; +case 699: + + parser.suggestValueExpressionKeywords($$[$0-2], ['WHEN']); + this.$ = { types: [ 'T' ], typeSet: true }; + +break; +case 700: + + this.$ = $$[$0]; + this.$.suggestFilters = $$[$0-1].suggestFilters; + +break; +case 701: +this.$ = { types: [ 'T' ], suggestFilters: $$[$0-1].suggestFilters }; +break; +case 703: case 705: + + $$[$0].position = 1; + +break; +case 704: + + $$[$0].position = $$[$0-2].position + 1; + this.$ = $$[$0]; + +break; +case 706: + + $$[$0-2].position += 1; + +break; +case 707: + + $$[$0-2].position = 1; + +break; +case 708: + + $$[$0-4].position += 1; + +break; +case 709: + + parser.valueExpressionSuggest(); + $$[$0-2].position += 1; + +break; +case 710: + + parser.valueExpressionSuggest(); + $$[$0-4].position += 1; + +break; +case 711: + + parser.suggestValueExpressionKeywords($$[$0-3]); + +break; +case 712: case 713: + + parser.valueExpressionSuggest(); + this.$ = { cursorAtStart : true, position: 1 }; + +break; +case 714: case 715: + + parser.valueExpressionSuggest(); + this.$ = { position: 2 }; + +break; +case 718: + + var lastLoc = parser.yy.locations[parser.yy.locations.length - 1]; + if (lastLoc.type !== 'variable') { + lastLoc.type = 'column'; + } + // used for function references with db prefix + var firstLoc = parser.yy.locations[parser.yy.locations.length - $$[$0].length]; + this.$ = { chain: $$[$0], firstLoc: firstLoc, lastLoc: lastLoc } + +break; +case 725: + + parser.suggestValues($$[$0]); + +break; +case 726: +this.$ = { types: [ 'NUMBER' ], text: $$[$0] }; +break; +case 732: case 734: case 735: +this.$ = $$[$0-1] + $$[$0]; +break; +case 733: case 736: +this.$ = $$[$0-2] + $$[$0-1] + $$[$0]; +break; +case 737: +this.$ = $$[$0-3] + $$[$0-2] + $$[$0-1] + $$[$0]; +break; +case 738: + + if (/\$\{[^}]*\}/.test($$[$0])) { + parser.addVariableLocation(_$[$0], $$[$0]); + this.$ = { types: [ 'STRING' ], columnReference: [{ name: $$[$0] }], text: "'" + $$[$0] + "'" } + } else { + this.$ = { types: [ 'STRING' ] } + } + +break; +case 739: + + if (/\$\{[^}]*\}/.test($$[$0])) { + parser.addVariableLocation(_$[$0], $$[$0]); + this.$ = { types: [ 'STRING' ], columnReference: [{ name: $$[$0] }], text: '"' + $$[$0] + '"' } + } else { + this.$ = { types: [ 'STRING' ], text: '"' + $$[$0] + '"' } + } + +break; +case 740: +this.$ = { types: [ 'BOOLEAN' ], text: $$[$0] }; +break; +case 741: + + this.$ = { partialQuote: '\'', missingEndQuote: parser.yy.missingEndQuote }; + +break; +case 742: + + this.$ = { partialQuote: '"', missingEndQuote: parser.yy.missingEndQuote }; + +break; +case 749: + + this.$ = $$[$0]; + + if (parser.yy.latestTablePrimaries.length > 0) { + var idx = parser.yy.latestTablePrimaries.length - 1; + var tables = []; + do { + var tablePrimary = parser.yy.latestTablePrimaries[idx]; + if (!tablePrimary.subQueryAlias) { + tables.unshift(tablePrimary.alias ? { identifierChain: tablePrimary.identifierChain, alias: tablePrimary.alias } : { identifierChain: tablePrimary.identifierChain }) + } + idx--; + } while (idx >= 0 && tablePrimary.join && !tablePrimary.subQueryAlias) + + if (tables.length > 0) { + this.$.suggestJoins = { + prependJoin: true, + tables: tables + }; + } + } + +break; +case 756: + + this.$ = { + primary: $$[$0-1] + } + if ($$[$0-1].identifierChain) { + if ($$[$0]) { + $$[$0-1].alias = $$[$0].alias + parser.addTableAliasLocation($$[$0].location, $$[$0].alias, $$[$0-1].identifierChain); + } + parser.addTablePrimary($$[$0-1]); + } + + var keywords = []; + if (!$$[$0]) { + keywords = ['AS']; + } else if ($$[$0].suggestKeywords) { + keywords = $$[$0].suggestKeywords; + } + if (keywords.length > 0) { + this.$.suggestKeywords = keywords; + } + +break; +case 757: + + this.$ = { + primary: $$[$0-1] + }; + + if ($$[$0]) { + this.$.primary.alias = $$[$0].alias; + parser.addTablePrimary({ subQueryAlias: $$[$0].alias }); + parser.addSubqueryAliasLocation($$[$0].location, $$[$0].alias, $$[$0-1].identifierChain); + } + + var keywords = []; + if (!$$[$0]) { + keywords = ['AS']; + } + if (keywords.length > 0) { + this.$.suggestKeywords = keywords; + } + +break; +case 758: + + if ($$[$0]) { + parser.addTableAliasLocation($$[$0].location, $$[$0].alias, $$[$0-1].identifierChain); + } + +break; +case 759: + + if ($$[$0]) { + parser.addTablePrimary({ subQueryAlias: $$[$0].alias }); + parser.addSubqueryAliasLocation($$[$0].location, $$[$0].alias); + } + +break; +case 769: + + parser.pushQueryState(); + +break; +case 770: + + parser.popQueryState(); + +break; +case 772: + + if ($$[$0-1]) { + $$[$0-2].alias = $$[$0-1].alias; + parser.addTablePrimary({ subQueryAlias: $$[$0-1].alias }); + parser.addSubqueryAliasLocation($$[$0-1].location, $$[$0-1].alias, $$[$0-2].identifierChain); + } + this.$ = $$[$0-2]; + +break; +case 775: + + var subQuery = parser.getSubQuery($$[$0]); + subQuery.columns.forEach(function (column) { + parser.expandIdentifierChain({ wrapper: column }); + delete column.linked; + }); + parser.popQueryState(subQuery); + this.$ = subQuery; + +break; +case 792: case 793: case 794: case 795: +this.$ = { alias: $$[$0], location: _$[$0] }; +break; +case 802: case 803: + + if (parser.yy.result.suggestFunctions) { + parser.suggestAggregateFunctions(); + } + +break; +case 804: + + if (!$$[$0-2] && !$$[$0-1]) { + parser.suggestKeywords([{ value: 'PARTITION BY', weight: 2 }, { value: 'ORDER BY', weight: 1 }]); + } else if (!$$[$0-2]) { + parser.suggestKeywords(['PARTITION BY']); + } + +break; +case 805: + + if (!$$[$0-1]) { + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'ORDER BY', weight: 2 }]); + } else { + parser.suggestValueExpressionKeywords($$[$0-3]); + } + +break; +case 809: + + parser.suggestKeywords(['BY']); + +break; +case 814: + + // Only allowed in last order by + delete parser.yy.result.suggestAnalyticFunctions; + +break; +case 815: + + var keywords = []; + if ($$[$0-2].suggestKeywords) { + keywords = parser.createWeightedKeywords($$[$0-2].suggestKeywords, 2); + } + if (!$$[$0]) { + keywords = keywords.concat([{ value: 'RANGE BETWEEN', weight: 1 }, { value: 'ROWS BETWEEN', weight: 1 }]); + } + parser.suggestKeywords(keywords); + +break; +case 821: + + parser.suggestKeywords(['BETWEEN']); + +break; +case 822: + + if (!$$[$0-2] && !$$[$0-1]) { + parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED PRECEDING']); + } else if (!$$[$0-1]) { + parser.suggestKeywords(['AND']); + } + +break; +case 827: + + lexer.popState(); + +break; +case 828: + + lexer.begin('hdfs'); + +break; +case 830: + + parser.suggestHdfs({ path: $$[$0-3] }); + +break; +case 831: + + parser.suggestHdfs({ path: $$[$0-2] }); + +break; +case 832: + + parser.suggestHdfs({ path: $$[$0-1] }); + +break; +case 833: + + parser.suggestHdfs({ path: '' }); + +break; +case 834: + + parser.suggestHdfs({ path: '' }); + +break; +case 840: + + parser.suggestKeywords(['PRECEDING']); + +break; +case 841: case 846: + + parser.suggestKeywords(['ROW']); + +break; +case 845: + + parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED FOLLOWING']); + +break; +case 847: + + parser.suggestKeywords(['FOLLOWING']); + +break; +case 851: +this.$ = { inValueEdit: true }; +break; +case 852: +this.$ = { inValueEdit: true, cursorAtStart: true }; +break; +case 853: case 854: case 855: + + this.$ = { suggestKeywords: ['NOT'] } + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 859: case 860: case 861: + + parser.suggestFunctions({ types: [ 'STRING' ] }); + parser.suggestColumns({ types: [ 'STRING' ] }); + this.$ = { types: ['BOOLEAN'] } + +break; +case 862: + + this.$ = parser.findCaseType($$[$0-1]) + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 863: + + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + parser.extractExpressionText(this.$, $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 864: +this.$ = parser.findCaseType($$[$0-1]); +break; +case 865: + + parser.suggestValueExpressionKeywords($$[$0-1], ['END']); + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 866: + + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 867: +this.$ = parser.findCaseType($$[$0-2]); +break; +case 868: + + if ($$[$0].toLowerCase() !== 'end') { + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'END', weight: 3 }, { value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } else { + parser.suggestValueExpressionKeywords($$[$0-3], [{ value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 869: + + if ($$[$0].toLowerCase() !== 'end') { + parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'END', weight: 3 }, { value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } else { + parser.suggestValueExpressionKeywords($$[$0-2], [{ value: 'ELSE', weight: 2 }, { value: 'WHEN', weight: 1 }]); + } + this.$ = parser.findCaseType($$[$0-2]); + +break; +case 870: + + $$[$0-3].caseTypes.push($$[$0-1]); + this.$ = parser.findCaseType($$[$0-3]); + this.$.suggestFilters = $$[$0-1].suggestFilters + +break; +case 871: + + parser.valueExpressionSuggest(); + this.$ = parser.findCaseType($$[$0-3]); + +break; +case 872: + + parser.valueExpressionSuggest(); + this.$ = { types: [ 'T' ], typeSet: true }; + +break; +case 873: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = $$[$0-1]; + +break; +case 874: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { types: [ 'T' ] }; + +break; +case 877: + + this.$ = { caseTypes: [ $$[$0] ], lastType: $$[$0] } + parser.extractExpressionText(this.$, $$[$0]); + +break; +case 878: + + $$[$0-1].caseTypes.push($$[$0]); + this.$ = { caseTypes: $$[$0-1].caseTypes, lastType: $$[$0] }; + parser.extractExpressionText(this.$, $$[$0-1], $$[$0]); + +break; +case 882: + + parser.suggestValueExpressionKeywords($$[$0-2], ['WHEN']); + +break; +case 884: + + this.$ = $$[$0] + parser.extractExpressionText(this.$, $$[$0-3], $$[$0-2], $$[$0-1], $$[$0]); + +break; +case 885: +this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0].suggestFilters }; +break; +case 886: +this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: $$[$0-1].suggestFilters }; +break; +case 887: +this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0-2].suggestFilters }; +break; +case 888: case 889: +this.$ = { caseTypes: [$$[$0]], suggestFilters: $$[$0].suggestFilters }; +break; +case 890: + + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 891: + + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [$$[$0]] }; + +break; +case 892: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 893: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['WHEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 894: case 896: + + parser.valueExpressionSuggest(); + this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true }; + +break; +case 895: + + parser.valueExpressionSuggest(); + parser.suggestKeywords(['THEN']); + this.$ = { caseTypes: [{ types: ['T'] }], suggestFilters: true }; + +break; +case 897: + + parser.valueExpressionSuggest(); + this.$ = { caseTypes: [$$[$0]], suggestFilters: true }; + +break; +case 898: + + parser.suggestValueExpressionKeywords($$[$0-1], ['THEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 899: + + parser.suggestValueExpressionKeywords($$[$0-2], ['THEN']); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +case 900: case 901: case 902: case 903: + + parser.valueExpressionSuggest(); + this.$ = { caseTypes: [{ types: ['T'] }] }; + +break; +} +}, +table: [o($V0,$V1,{171:1,113:2}),{1:[3]},o($V2,$V3,{172:3,176:4,3:7,4:8,5:9,13:$V4,90:$V5,179:$V6,180:$V7}),{173:[1,12],177:[1,13]},o($V2,[2,317]),o($V2,[2,323]),o($V2,[2,324]),o($V2,[2,325]),{5:14,7:[1,15],90:$V5},o($V8,$V9,{6:16,108:17,110:18,112:$Va}),{14:20,16:21,19:22,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg},o([7,77,103,138,139,140,141,142,143,144,145,146,147,148,150,151,152,153,154,160,185,186,187,188,190,191,192,198,201,205,212,215,216,225,237,244,245,246],$Vh,{91:31,96:$Vi,97:$Vj}),{1:[2,312]},o($V0,$V1,{113:34}),o($V8,$V9,{108:17,110:18,6:35,112:$Va}),{3:36,4:8,5:9,13:$V4,90:$V5},o($V8,[2,3]),o($V8,[2,193],{110:37,112:$Va}),o($Vk,[2,195]),o([90,96,97],$V1,{113:38}),o([7,90],[2,12],{17:[1,39]}),o($Vl,[2,14]),{20:[1,40]},o($Vm,[2,542]),{201:[1,42],255:[1,41]},o($Vm,[2,335]),o($Vm,[2,336]),o($Vm,[2,337]),o($Vm,[2,332]),o($Vm,[2,333]),o($Vm,[2,334]),{7:$Vn,19:77,45:45,76:75,77:$Vb,92:43,100:44,103:$Vo,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($VT,[2,155]),o($VT,[2,156]),o($V2,$V3,{176:4,3:7,4:8,5:9,172:101,13:$V4,90:$V5,179:$V6,180:$V7}),o($V8,[2,1]),{8:[1,102]},o($Vk,[2,196]),{90:$Vh,91:103,96:$Vi,97:$Vj},{16:104,19:22,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg},{7:[1,105]},{201:[1,106]},o($Vm,[2,544]),o($Vk,[2,144],{93:107,26:109,17:[1,108],27:[1,110]}),o($VU,[2,161]),o($VU,$VV,{166:23,184:27,102:111,317:125,19:126,260:127,254:132,258:133,20:$VW,77:$Vb,103:$VX,185:$Vc,186:$Vd,187:$Ve,188:$Vf,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,201:$Vg,202:$V21,207:$V31,212:$VL,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,237:$VP}),o($VU,[2,177]),o($Vb1,[2,586]),{7:$Vn,19:77,45:134,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:135,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:136,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:137,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vc1,314:138},{7:$Vn,19:77,45:140,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:142,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,249:$Vd1,254:83,258:84,293:69,306:60,318:141,328:68,330:76,332:81,333:82,334:85,382:143,384:144},o($Vb1,[2,277],{158:146,7:$Ve1}),{7:$Ve1,158:148},o($Vb1,[2,275]),o($Vb1,[2,276]),o($Vb1,[2,278]),o($Vf1,[2,718],{192:[1,149]}),{7:[2,257]},{7:[2,258]},{7:[2,259]},{7:[2,260]},o($Vb1,[2,306],{119:150,121:151,168:$Vg1}),{121:153,168:$Vg1},o($Vb1,[2,214]),o($Vb1,[2,724]),o($Vh1,[2,556]),o($Vi1,[2,222]),o($Vi1,[2,223]),o($Vi1,[2,224]),{7:[1,154]},{7:[1,155]},o($Vb1,[2,726]),o($Vb1,[2,727]),o($Vh1,[2,566]),{7:[1,156]},{7:[1,157]},{7:[1,158]},o($Vb1,[2,729]),o($Vb1,[2,730]),o($Vb1,[2,738]),o($Vb1,[2,739]),o($Vb1,[2,740]),{7:[2,233]},{7:[2,234]},{7:[2,235]},{7:[2,236]},{7:[2,237]},{7:[2,238]},{7:[2,239]},{7:[2,240]},o($Vb1,[2,731],{192:[1,159]}),{245:[1,160],246:[1,161]},{245:[1,162]},{237:[1,164],255:[1,163]},{212:[1,166],255:[1,165]},o($Vb1,[2,743]),o($Vb1,[2,744]),o($V2,[2,318]),o($V8,$V9,{108:17,110:18,6:167,112:$Va}),{5:168,90:$V5},o($Vl,[2,15]),o($Vj1,$Vk1,{21:169,345:170}),o($Vm,[2,543]),o($Vk,[2,145]),{7:$Vn,19:77,45:45,76:75,77:$Vb,100:171,103:$Vo,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vl1,[2,205],{98:172,105:173,107:174,114:[1,175]}),{7:$Vc1,19:185,28:176,31:177,56:179,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,296:183,314:184,335:178,337:180,339:181,340:182},o($VU,[2,176]),o($Vm1,[2,745],{313:186,225:[1,187]}),{7:$Vn,19:77,45:188,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:189,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:190,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:191,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{202:[1,193],220:[1,192],224:$V61,231:$V91,232:$Va1,317:194},{7:[1,195]},{7:$Vn,19:77,45:196,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:197,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:198,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:199,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:200,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:201,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vb1,[2,612]),o($Vn1,[2,792]),o($Vn1,[2,793]),{19:202,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,212:$VL,237:$VP,254:132,258:133,260:203},{7:$Vn,19:77,45:204,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:205,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:206,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vn1,[2,460]),o($Vn1,[2,461]),o($Vo1,[2,587],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,207:$V31,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($Vo1,[2,588],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,207:$V31,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($Vo1,[2,589],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,207:$V31,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($Vp1,[2,590],{317:125}),o($Vb1,[2,595]),o($Vj1,$Vk1,{345:170,314:184,21:207,340:208,7:$Vc1}),{8:[1,209],103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,317:125},o($Vb1,[2,614]),{103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,249:$Vd1,317:125,318:210,382:143,384:144},{213:[1,212],214:[1,211],249:$Vd1,384:213},o($Vq1,[2,877]),{7:$Vn,19:77,45:214,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vb1,[2,273]),{7:$Vn,8:[1,215],19:77,45:217,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,136:216,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vb1,[2,274]),{19:77,77:$Vb,103:[1,218],166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,293:219},o($Vb1,[2,212]),o($Vb1,[2,307]),{7:[1,222],19:220,77:$Vb,166:23,169:221,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg},o($Vb1,[2,213]),{7:$Vn,8:[1,223],19:77,45:217,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,136:224,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,8:[1,226],19:77,45:225,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o([7,8,77,138,139,140,141,142,143,144,145,146,147,148,150,151,152,153,154,160,185,186,187,188,190,191,192,198,201,205,212,215,216,225,237,244,245,246],$Vh,{91:227,96:$Vi,97:$Vj}),o($Vr1,$Vh,{91:230,8:[1,229],96:$Vi,97:$Vj,103:[1,228]}),o($Vr1,$Vh,{91:231,8:[1,232],96:$Vi,97:$Vj}),o($Vb1,[2,732],{245:[1,233],246:[1,234]}),o($Vb1,[2,734]),{245:[1,235]},o($Vb1,[2,735]),{237:[1,236]},o($Vs1,[2,455]),{212:[1,237]},o($Vs1,[2,458]),o($V8,[2,2]),o($Vk,[2,201]),{8:[1,238]},{3:246,4:8,5:9,13:$V4,90:$V5,347:239,349:240,351:241,353:242,355:243,357:244,359:245},o($VU,[2,162]),o($Vk,[2,157]),o($Vt1,[2,34],{33:247,34:248,35:[1,249]}),o($Vl1,[2,206]),{7:$Vn,19:77,45:251,76:75,77:$Vb,115:250,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o([8,35,50,75,81,112,114,173,177],[2,24],{17:[1,252]}),o($Vu1,[2,27]),o($Vu1,[2,747]),o($Vu1,[2,749],{53:253,55:254,63:$Vv1,64:$Vw1,65:$Vx1,66:$Vy1,67:$Vz1,68:$VA1,69:$VB1,70:$VC1}),o($Vu1,[2,750]),o($VD1,$VV,{166:23,184:27,19:126,260:127,254:132,258:133,102:263,20:$VW,77:$Vb,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,212:$VL,237:$VP}),o($VD1,$VV,{166:23,184:27,19:126,260:127,254:132,258:133,102:264,20:$VW,77:$Vb,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,212:$VL,237:$VP}),o($VE1,[2,761]),o($VE1,[2,763]),o($VE1,[2,519],{192:[1,265]}),{97:[1,269],160:[1,266],216:[1,268],244:[1,267]},o($Vm1,[2,746]),o($VF1,[2,597],{317:125,103:$VX,191:$VY,200:$V11,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($VF1,[2,598],{317:125,103:$VX,191:$VY,200:$V11,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($VF1,[2,599],{317:125,103:$VX,191:$VY,200:$V11,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($VF1,[2,600],{317:125,103:$VX,191:$VY,200:$V11,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),{7:[1,270]},{7:$Vn,19:77,45:271,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vb1,[2,613]),o($Vj1,$Vk1,{166:23,184:27,156:47,157:55,149:56,117:57,159:58,306:60,118:65,120:66,122:67,328:68,293:69,129:70,130:71,131:72,76:75,330:76,19:77,135:78,332:81,333:82,254:83,258:84,334:85,345:170,21:272,315:273,45:274,7:$Vn,77:$Vb,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,160:$VF,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS}),{103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,316:[1,275],317:125},o($VG1,[2,607],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,231:$V91,232:$Va1}),o($VG1,[2,608],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,231:$V91,232:$Va1}),o($Vp1,[2,609],{317:125,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($Vp1,[2,610],{317:125,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($Vp1,[2,611],{317:125,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($Vn1,[2,794]),o($Vn1,[2,795]),o($Vp1,[2,853],{317:125}),o($Vp1,[2,854],{317:125}),o($Vp1,[2,855],{317:125}),{8:[1,276]},{8:$VV,19:126,20:$VW,77:$Vb,102:277,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,212:$VL,237:$VP,254:132,258:133,260:127},o($Vb1,[2,596]),o($Vb1,[2,615]),o($Vb1,[2,862]),{7:$Vn,19:77,45:278,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vq1,[2,878]),{103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,241:[1,279],317:125},o($Vb1,[2,288]),{8:[1,280],17:$VH1},o($VI1,[2,293],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($Vf1,[2,719]),o($Vh1,[2,557]),o($Vb1,[2,309]),o($Vb1,[2,310]),o($VJ1,[2,806],{361:282,365:283,227:[1,284]}),{168:[2,252]},{8:[1,285],17:$VH1},{20:[1,286],103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,317:125},o($Vb1,[2,262]),{7:$Vn,8:[1,287],19:77,45:217,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,136:288,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{8:[1,289]},o($Vi1,[2,242]),{7:$Vn,19:77,45:217,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,136:290,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,45:291,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vi1,[2,248]),o($Vb1,[2,733]),{245:[1,292]},o($Vb1,[2,736]),o($Vs1,[2,454]),o($Vs1,[2,457]),o($Vl,[2,20]),{8:[2,775]},{8:[2,777]},{8:[2,779]},{8:[2,781]},{8:[2,783]},{8:[2,785]},{8:[2,787]},{8:[2,789]},o($VK1,[2,63],{48:293,49:294,50:[1,295]}),o($Vt1,[2,35]),{36:[1,296]},o($Vl1,[2,207]),o($Vl1,[2,210],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),{7:$Vc1,19:185,31:297,56:179,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,296:183,314:184,335:178,337:180,339:181,340:182},o($Vu1,[2,753],{55:298,63:$Vv1,64:$Vw1,65:$Vx1,66:$Vy1,67:$Vz1,68:$VA1,69:$VB1,70:$VC1}),{7:$Vc1,19:185,56:299,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,296:183,314:184,339:181,340:182},{64:[1,300]},{64:[1,301],66:[1,302]},{64:[1,303]},o($VL1,[2,88]),{64:[1,305],66:[1,306],67:[1,304],69:[1,307]},{64:[1,308]},{64:[1,310],66:[1,311],67:[1,309],69:[1,312]},{64:[1,313]},o($VD1,[2,756]),o($VD1,[2,757]),{19:314,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg},o($Vb1,[2,591]),o($Vb1,[2,592]),o($Vb1,[2,593]),{27:[1,315]},o($Vj1,$Vk1,{166:23,184:27,156:47,157:55,149:56,117:57,159:58,306:60,118:65,120:66,122:67,328:68,293:69,129:70,130:71,131:72,76:75,330:76,19:77,135:78,332:81,333:82,254:83,258:84,334:85,345:170,45:274,21:316,315:317,7:$Vn,77:$Vb,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,160:$VF,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS}),{103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,316:[1,318],317:125},{8:[1,319]},{8:[1,320],17:$VM1},o($VN1,[2,703],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),{7:$Vn,19:77,45:322,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vs1,[2,771]),{8:[1,323]},{103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,214:[1,324],220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,317:125},{7:$Vn,19:77,45:325,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vb1,[2,289]),{7:$Vn,19:77,45:326,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{8:[2,812],80:328,81:$VO1,362:327},o($VJ1,[2,807]),{36:[1,330]},{168:[2,253]},{155:331,203:[1,332],204:[1,333],206:[1,334],210:[1,335],211:[1,336],217:[1,337],221:[1,338],238:[1,339],239:[1,340],242:[1,341],243:[1,342],248:[1,343]},o($Vi1,[2,228]),{8:[1,344],17:$VH1},o($Vi1,[2,241]),{8:[1,345],17:$VH1},{8:[1,346],103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1,317:125},o($Vb1,[2,737]),o($VP1,[2,126],{79:347,80:348,81:$VO1}),o($VK1,[2,64]),{7:$Vn,19:77,45:349,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{7:$Vn,19:77,37:350,45:351,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vu1,[2,28]),{7:$Vc1,19:185,56:352,77:$Vb,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,201:$Vg,296:183,314:184,339:181,340:182},o($VQ1,$VR1,{57:353,71:$VS1}),o($VL1,[2,84]),o($VL1,[2,85]),{64:[1,355]},o($VL1,[2,87]),{64:[1,356]},o($VL1,[2,90]),{64:[1,357]},{64:[1,358]},o($VL1,[2,93]),{64:[1,359]},o($VL1,[2,95]),{64:[1,360]},{64:[1,361]},o($VL1,[2,98]),o($VE1,[2,520]),{7:$Vn,19:77,45:362,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},{8:[1,363]},{8:[1,364],17:$VM1},{7:$Vn,19:77,45:365,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($Vb1,[2,603]),o($Vb1,[2,604]),{7:$Vn,19:77,45:366,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o([8,17,20,27,35,50,63,64,65,66,67,68,69,70,75,77,81,88,89,112,114,173,177,185,186,187,188,199,201,202,212,213,214,226,230,234,237,241,249,316],[2,606],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,231:$V91,232:$Va1}),o($Vs1,[2,772]),o($Vb1,[2,863]),o($Vq1,[2,884],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($VI1,[2,294],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),{8:[1,367]},{8:[2,817],230:[1,372],234:[1,371],366:368,368:369,369:370},{36:[1,373]},{7:$Vn,19:77,45:274,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,315:374,328:68,330:76,332:81,333:82,334:85},{8:[1,375]},{8:[2,569]},{8:[2,570]},{7:$VT1,8:$VU1,311:376},{7:[1,379],8:[2,583],312:378},{8:[2,573]},{8:[2,574]},{8:[2,575]},{8:[2,576]},{8:[2,577]},{8:[2,578]},{8:[2,579]},{7:$VT1,8:$VU1,311:380},o($Vi1,[2,229]),o($Vi1,[2,243]),o($Vi1,[2,247]),o($Vk,[2,119],{73:381,74:382,75:[1,383]}),o($VP1,[2,127]),o($VK1,[2,65],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($Vt1,[2,36],{17:[1,384]}),o($VV1,[2,51],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($VQ1,$VR1,{57:385,71:$VS1}),o($VQ1,[2,71]),{7:$Vn,19:77,45:386,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($VL1,[2,86]),o($VL1,[2,89]),o($VL1,[2,91]),o($VL1,[2,92]),o($VL1,[2,94]),o($VL1,[2,96]),o($VL1,[2,97]),o($Vp1,[2,594],{317:125}),o($Vb1,[2,601]),o($Vb1,[2,602]),o($Vo1,[2,605],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,200:$V11,207:$V31,220:$V41,223:$V51,224:$V61,231:$V91,232:$Va1}),o($VN1,[2,704],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($Vb1,[2,801]),{8:[2,813]},{8:[2,818]},{202:[1,387],373:[1,388]},o($VW1,[2,835]),o($VW1,[2,836]),{7:$Vn,19:77,45:391,76:75,77:$Vb,82:389,85:390,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($VJ1,[2,808],{17:$VM1}),o($Vb1,[2,261]),{8:[2,571]},{245:[1,392]},{8:[2,572]},{245:[1,393]},{8:[2,580]},o($Vk,[2,181]),o($Vk,[2,120]),{76:394,77:[1,395],192:$VI,245:$VR,246:$VS,332:81,333:82},{7:$Vn,19:77,45:396,76:75,77:$Vb,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($VQ1,[2,72]),o($VQ1,[2,114],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($VX1,$VY1,{370:397}),o($VX1,$VY1,{370:398}),o([8,75,112,173,177,230,234],[2,128],{17:[1,399]}),o($VZ1,[2,131]),o($VZ1,[2,141],{317:125,87:400,88:[1,401],89:[1,402],103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),{8:[1,403]},{8:[1,404],17:[1,405]},o($Vk,[2,121],{17:[1,406]}),o($Vk,[2,123],{17:[1,407]}),o($VV1,[2,52],{317:125,103:$VX,191:$VY,193:$VZ,194:$V_,195:$V$,199:$V01,200:$V11,202:$V21,207:$V31,220:$V41,223:$V51,224:$V61,225:$V71,226:$V81,231:$V91,232:$Va1}),o($V_1,$V$1,{371:408,381:409,208:$V02,245:$V12,373:$V22}),o($V_1,$V$1,{381:409,371:413,208:$V02,245:$V12,373:$V22}),{7:$Vn,19:77,45:391,76:75,77:$Vb,85:414,117:57,118:65,120:66,122:67,129:70,130:71,131:72,135:78,138:$Vp,139:$Vq,140:$Vr,141:$Vs,142:$Vt,143:$Vu,144:$Vv,145:$Vw,146:$Vx,147:$Vy,148:$Vz,149:56,150:$VA,151:$VB,152:$VC,153:$VD,154:$VE,156:47,157:55,159:58,160:$VF,166:23,184:27,185:$Vc,186:$Vd,187:$Ve,188:$Vf,190:$VG,191:$VH,192:$VI,198:$VJ,201:$Vg,205:$VK,212:$VL,215:$VM,216:$VN,225:$VO,237:$VP,244:$VQ,245:$VR,246:$VS,254:83,258:84,293:69,306:60,328:68,330:76,332:81,333:82,334:85},o($VZ1,[2,138]),o($VZ1,[2,142]),o($VZ1,[2,143]),{8:[2,582]},{8:[2,584]},{245:[1,415]},{76:416,192:$VI,245:$VR,246:$VS,332:81,333:82},{77:[1,417]},{8:$V32,199:$V42,372:418},{228:[1,420]},{233:[1,421]},o($V52,[2,848]),o($V52,[2,849]),{8:$V32,199:$V42,372:422},o($VZ1,[2,132]),{8:[1,423]},o($Vk,[2,122]),o($Vk,[2,124]),{8:[2,819]},{208:[1,424],245:$V12,373:$V22,381:425},o($V_1,[2,838]),o($V_1,[2,839]),{8:[2,820]},{8:[2,585]},{233:[1,426]},{218:[1,427]},{8:[2,843]},{8:[2,844]}], +defaultActions: {12:[2,312],61:[2,257],62:[2,258],63:[2,259],64:[2,260],86:[2,233],87:[2,234],88:[2,235],89:[2,236],90:[2,237],91:[2,238],92:[2,239],93:[2,240],223:[2,252],239:[2,775],240:[2,777],241:[2,779],242:[2,781],243:[2,783],244:[2,785],245:[2,787],246:[2,789],285:[2,253],332:[2,569],333:[2,570],336:[2,573],337:[2,574],338:[2,575],339:[2,576],340:[2,577],341:[2,578],342:[2,579],368:[2,813],369:[2,818],376:[2,571],378:[2,572],380:[2,580],403:[2,582],404:[2,584],418:[2,819],422:[2,820],423:[2,585],426:[2,843],427:[2,844]}, +parseError: function parseError (str, hash) { + if (hash.recoverable) { + this.trace(str); + } else { + var error = new Error(str); + error.hash = hash; + throw error; + } +}, +/** + * @param {string} input + * + * @return {AutocompleteParseResult} + */ +parse: function parse (input) { + var self = this, + stack = [0], + tstack = [], // token stack + vstack = [null], // semantic value stack + lstack = [], // location stack + table = this.table, + yytext = '', + yylineno = 0, + yyleng = 0, + recovering = 0, + TERROR = 2, + EOF = 1; + + var args = lstack.slice.call(arguments, 1); + + //this.reductionCount = this.shiftCount = 0; + + var lexer = Object.create(this.lexer); + var sharedState = { yy: {} }; + // copy state + for (var k in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k)) { + sharedState.yy[k] = this.yy[k]; + } + } + + lexer.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer; + sharedState.yy.parser = this; + if (typeof lexer.yylloc == 'undefined') { + lexer.yylloc = {}; + } + var yyloc = lexer.yylloc; + lstack.push(yyloc); + + var ranges = lexer.options && lexer.options.ranges; + + if (typeof sharedState.yy.parseError === 'function') { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + + function popStack (n) { + stack.length = stack.length - 2 * n; + vstack.length = vstack.length - n; + lstack.length = lstack.length - n; + } + +_token_stack: + var lex = function () { + var token; + token = lexer.lex() || EOF; + // if token isn't its numeric value, convert + if (typeof token !== 'number') { + token = self.symbols_[token] || token; + } + return token; + } + + var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected; + while (true) { + // retreive state number from top of stack + state = stack[stack.length - 1]; + + // use default actions if available + if (this.defaultActions[state]) { + action = this.defaultActions[state]; + } else { + if (symbol === null || typeof symbol == 'undefined') { + symbol = lex(); + } + // read action for current state and first input + action = table[state] && table[state][symbol]; + } + +_handle_error: + // handle parse error + if (typeof action === 'undefined' || !action.length || !action[0]) { + var error_rule_depth; + var errStr = ''; + + // Return the rule stack depth where the nearest error rule can be found. + // Return FALSE when no error recovery rule was found. + function locateNearestErrorRecoveryRule(state) { + var stack_probe = stack.length - 1; + var depth = 0; + + // try to recover from error + for(;;) { + // check for error recovery rule in this state + if ((TERROR.toString()) in table[state]) { + return depth; + } + if (state === 0 || stack_probe < 2) { + return false; // No suitable error recovery rule available. + } + stack_probe -= 2; // popStack(1): [symbol, action] + state = stack[stack_probe]; + ++depth; + } + } + + if (!recovering) { + // first see if there's any chance at hitting an error recovery rule: + error_rule_depth = locateNearestErrorRecoveryRule(state); + + // Report error + expected = []; + for (p in table[state]) { + if (this.terminals_[p] && p > TERROR) { + expected.push("'"+this.terminals_[p]+"'"); + } + } + if (lexer.showPosition) { + errStr = 'Parse error on line '+(yylineno+1)+":\n"+lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + (this.terminals_[symbol] || symbol)+ "'"; + } else { + errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " + + (symbol == EOF ? "end of input" : + ("'"+(this.terminals_[symbol] || symbol)+"'")); + } + this.parseError(errStr, { + text: lexer.match, + token: this.terminals_[symbol] || symbol, + line: lexer.yylineno, + loc: lexer.yylloc, + ruleId: stack.slice(stack.length - 2, stack.length).join('_'), + expected: expected, + recoverable: (error_rule_depth !== false) + }); + } else if (preErrorSymbol !== EOF) { + error_rule_depth = locateNearestErrorRecoveryRule(state); + } + + // just recovered from another error + if (recovering == 3) { + if (symbol === EOF || preErrorSymbol === EOF) { + throw new Error(errStr || 'Parsing halted while starting to recover from another error.'); + } + + // discard current lookahead and grab another + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + symbol = lex(); + } + + // try to recover from error + if (error_rule_depth === false) { + throw new Error(errStr || 'Parsing halted. No suitable error recovery rule available.'); + } + popStack(error_rule_depth); + + preErrorSymbol = (symbol == TERROR ? null : symbol); // save the lookahead token + symbol = TERROR; // insert generic error symbol as new lookahead + state = stack[stack.length-1]; + action = table[state] && table[state][TERROR]; + recovering = 3; // allow 3 real symbols to be shifted before reporting a new error + } + + // this shouldn't happen, unless resolve defaults are off + if (action[0] instanceof Array && action.length > 1) { + throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol); + } + + switch (action[0]) { + case 1: // shift + //this.shiftCount++; + + stack.push(symbol); + vstack.push(lexer.yytext); + lstack.push(lexer.yylloc); + stack.push(action[1]); // push state + symbol = null; + if (!preErrorSymbol) { // normal execution/no error + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + if (recovering > 0) { + recovering--; + } + } else { + // error just occurred, resume old lookahead f/ before error + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + + case 2: + // reduce + //this.reductionCount++; + + len = this.productions_[action[1]][1]; + + // perform semantic action + yyval.$ = vstack[vstack.length-len]; // default to $$ = $1 + // default location, uses first token for firsts, last for lasts + yyval._$ = { + first_line: lstack[lstack.length-(len||1)].first_line, + last_line: lstack[lstack.length-1].last_line, + first_column: lstack[lstack.length-(len||1)].first_column, + last_column: lstack[lstack.length-1].last_column + }; + if (ranges) { + yyval._$.range = [lstack[lstack.length-(len||1)].range[0], lstack[lstack.length-1].range[1]]; + } + r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args)); + + if (typeof r !== 'undefined') { + return r; + } + + // pop off stack + if (len) { + stack = stack.slice(0,-1*len*2); + vstack = vstack.slice(0, -1*len); + lstack = lstack.slice(0, -1*len); + } + + stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) + vstack.push(yyval.$); + lstack.push(yyval._$); + // goto new state = table[STATE][NONTERMINAL] + newState = table[stack[stack.length-2]][stack[stack.length-1]]; + stack.push(newState); + break; + + case 3: + // accept + return true; + } + + } + + return true; +}}; + + +SqlParseSupport.initSyntaxParser(parser);/* generated by jison-lex 0.3.4 */ +var lexer = (function(){ +var lexer = ({ + +EOF:1, + +parseError:function parseError(str, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str, hash); + } else { + throw new Error(str); + } + }, + +// resets the lexer, sets new input +setInput:function (input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ''; + this.conditionStack = ['INITIAL']; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) { + this.yylloc.range = [0,0]; + } + this.offset = 0; + return this; + }, + +// consumes and returns one char from the input +input:function () { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) { + this.yylloc.range[1]++; + } + + this._input = this._input.slice(1); + return ch; + }, + +// unshifts one char (or a string) into the input +unput:function (ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); + //this.yyleng -= len; + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + var r = this.yylloc.range; + + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? + (lines.length === oldLines.length ? this.yylloc.first_column : 0) + + oldLines[oldLines.length - lines.length].length - lines[0].length : + this.yylloc.first_column - len + }; + + if (this.options.ranges) { + this.yylloc.range = [r[0], r[0] + this.yyleng - len]; + } + this.yyleng = this.yytext.length; + return this; + }, + +// When called from action, caches matched text and appends it on next action +more:function () { + this._more = true; + return this; + }, + +// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. +reject:function () { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + + } + return this; + }, + +// retain first n characters of the match +less:function (n) { + this.unput(this.match.slice(n)); + }, + +// displays already matched input, i.e. for error messages +pastInput:function () { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); + }, + +// displays upcoming input, i.e. for error messages +upcomingInput:function () { + var next = this.match; + if (next.length < 20) { + next += this._input.substr(0, 20-next.length); + } + return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, ""); + }, + +// displays the character position where the lexing error occurred, i.e. for error messages +showPosition:function () { + var pre = this.pastInput(); + var c = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c + "^"; + }, + +// test the lexed token: return FALSE when not a match, otherwise return token +test_match:function(match, indexed_rule) { + var token, + lines, + backup; + + if (this.options.backtrack_lexer) { + // save context + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + + lines = match[0].match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno += lines.length; + } + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? + lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : + this.yylloc.last_column + match[0].length + }; + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) { + this.done = false; + } + if (token) { + return token; + } else if (this._backtrack) { + // recover context + for (var k in backup) { + this[k] = backup[k]; + } + return false; // rule action called reject() implying the next rule should be tested instead. + } + return false; + }, + +// return next match in input +next:function () { + if (this.done) { + return this.EOF; + } + if (!this._input) { + this.done = true; + } + + var token, + match, + tempMatch, + index; + if (!this._more) { + this.yytext = ''; + this.match = ''; + } + var rules = this._currentRules(); + for (var i = 0; i < rules.length; i++) { + tempMatch = this._input.match(this.rules[rules[i]]); + if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { + match = tempMatch; + index = i; + if (this.options.backtrack_lexer) { + token = this.test_match(tempMatch, rules[i]); + if (token !== false) { + return token; + } else if (this._backtrack) { + match = false; + continue; // rule action called reject() implying a rule MISmatch. + } else { + // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + if (match) { + token = this.test_match(match, rules[index]); + if (token !== false) { + return token; + } + // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + return false; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, + +// return next match that has a token +lex:function lex () { + var r = this.next(); + if (r) { + return r; + } else { + return this.lex(); + } + }, + +// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) +begin:function begin (condition) { + this.conditionStack.push(condition); + }, + +// pop the previously active lexer condition state off the condition stack +popState:function popState () { + var n = this.conditionStack.length - 1; + if (n > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, + +// produce the lexer rule set which is active for the currently active lexer condition state +_currentRules:function _currentRules () { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, + +// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available +topState:function topState (n) { + n = this.conditionStack.length - 1 - Math.abs(n || 0); + if (n >= 0) { + return this.conditionStack[n]; + } else { + return "INITIAL"; + } + }, + +// alias for begin(condition) +pushState:function pushState (condition) { + this.begin(condition); + }, + +// return the number of states currently on the stack +stateStackSize:function stateStackSize() { + return this.conditionStack.length; + }, +options: {"case-insensitive":true,"flex":true}, +performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { +var YYSTATE=YY_START; +switch($avoiding_name_collisions) { +case 0: /* skip whitespace */ +break; +case 1: /* skip comments */ +break; +case 2: /* skip comments */ +break; +case 3: parser.yy.partialCursor = false; parser.yy.cursorFound = yy_.yylloc; return 22; +break; +case 4: parser.yy.partialCursor = true; parser.yy.cursorFound = yy_.yylloc; return 251; +break; +case 5: this.popState(); return 316; +break; +case 6: return 96; +break; +case 7: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('ALTER', yy_.yylloc, yy.lexer.upcomingInput()); return 'ALTER'; +break; +case 8: return 199; +break; +case 9: return 20; +break; +case 10: return 88; +break; +case 11: this.begin('between'); return 202; +break; +case 12: return 203; +break; +case 13: return 204; +break; +case 14: return 36; +break; +case 15: return 267; +break; +case 16: return 205; +break; +case 17: return 206; +break; +case 18: return 'COLUMNS'; +break; +case 19: return 'COMMENT'; +break; +case 20: parser.determineCase(yy_.yytext); return 'CREATE'; +break; +case 21: return 63; +break; +case 22: return 208; +break; +case 23: return 209; +break; +case 24: return 210; +break; +case 25: return 89; +break; +case 26: return 97; +break; +case 27: return 200; +break; +case 28: return 211; +break; +case 29: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('DROP', yy_.yylloc, yy.lexer.upcomingInput()); return 'DROP'; +break; +case 30: return 213; +break; +case 31: return 214; +break; +case 32: parser.yy.correlatedSubQuery = true; return 215; +break; +case 33: return 216; +break; +case 34: return 217; +break; +case 35: return 218; +break; +case 36: parser.determineCase(yy_.yytext); return 27; +break; +case 37: return 65; +break; +case 38: return 35; +break; +case 39: return 50; +break; +case 40: return 151; +break; +case 41: return 220; +break; +case 42: return 67; +break; +case 43: return 'INSERT'; +break; +case 44: return 221; +break; +case 45: return 222; +break; +case 46: return 223; +break; +case 47: return 64; +break; +case 48: return 68; +break; +case 49: return 224; +break; +case 50: return 75; +break; +case 51: return 225; +break; +case 52: return 160; +break; +case 53: return 71; +break; +case 54: return 186; +break; +case 55: return 226; +break; +case 56: return 81; +break; +case 57: return 66; +break; +case 58: return 227; +break; +case 59: return 228; +break; +case 60: return 229; +break; +case 61: return 230; +break; +case 62: return 231; +break; +case 63: return 70; +break; +case 64: return 232; +break; +case 65: return 233; +break; +case 66: return 185; +break; +case 67: return 234; +break; +case 68: return 235; +break; +case 69: return 'SCHEMAS'; +break; +case 70: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SELECT', yy_.yylloc); return 90; +break; +case 71: return 69; +break; +case 72: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SET', yy_.yylloc); return 236; +break; +case 73: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('SHOW', yy_.yylloc); return 'SHOW'; +break; +case 74: return 238; +break; +case 75: return 239; +break; +case 76: return 240; +break; +case 77: return 'TABLES'; +break; +case 78: return 241; +break; +case 79: return 242; +break; +case 80: return 243; +break; +case 81: return 'TO'; +break; +case 82: return 244; +break; +case 83: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('TRUNCATE', yy_.yylloc, yy.lexer.upcomingInput()); return 153; +break; +case 84: return 373; +break; +case 85: return 112; +break; +case 86: parser.determineCase(yy_.yytext); return 'UPDATE'; +break; +case 87: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('USE', yy_.yylloc); return 'USE'; +break; +case 88: return 247; +break; +case 89: return 248; +break; +case 90: return 'VIEW'; +break; +case 91: return 249; +break; +case 92: return 114; +break; +case 93: parser.determineCase(yy_.yytext); parser.addStatementTypeLocation('WITH', yy_.yylloc); return 13; +break; +case 94: return 168; +break; +case 95: return 185; +break; +case 96: yy.lexer.unput('('); yy_.yytext = 'avg'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 138; +break; +case 97: yy.lexer.unput('('); yy_.yytext = 'cast'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 154; +break; +case 98: yy.lexer.unput('('); yy_.yytext = 'count'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 146; +break; +case 99: yy.lexer.unput('('); yy_.yytext = 'max'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 139; +break; +case 100: yy.lexer.unput('('); yy_.yytext = 'min'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 140; +break; +case 101: yy.lexer.unput('('); yy_.yytext = 'stddev_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 141; +break; +case 102: yy.lexer.unput('('); yy_.yytext = 'stddev_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 142; +break; +case 103: yy.lexer.unput('('); yy_.yytext = 'sum'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 147; +break; +case 104: yy.lexer.unput('('); yy_.yytext = 'var_pop'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 143; +break; +case 105: yy.lexer.unput('('); yy_.yytext = 'var_samp'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 144; +break; +case 106: yy.lexer.unput('('); yy_.yytext = 'variance'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 145; +break; +case 107: yy.lexer.unput('('); yy_.yytext = 'cume_dist'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 108: yy.lexer.unput('('); yy_.yytext = 'dense_rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 109: yy.lexer.unput('('); yy_.yytext = 'first_value'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 110: yy.lexer.unput('('); yy_.yytext = 'lag'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 111: yy.lexer.unput('('); yy_.yytext = 'last_value'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 112: yy.lexer.unput('('); yy_.yytext = 'lead'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 113: yy.lexer.unput('('); yy_.yytext = 'rank'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 114: yy.lexer.unput('('); yy_.yytext = 'row_number'; parser.addFunctionLocation(yy_.yylloc, yy_.yytext); return 148; +break; +case 115: return 245; +break; +case 116: return 245; +break; +case 117: return 246; +break; +case 118: return 188; +break; +case 119: parser.yy.cursorFound = true; return 22; +break; +case 120: parser.yy.cursorFound = true; return 251; +break; +case 121: return 219; +break; +case 122: parser.addFileLocation(yy_.yylloc, yy_.yytext); return 378; +break; +case 123: this.popState(); return 379; +break; +case 124: return 173; +break; +case 125: return 199; +break; +case 126: return 226; +break; +case 127: return 194; +break; +case 128: return 193; +break; +case 129: return 195; +break; +case 130: return 207; +break; +case 131: return 207; +break; +case 132: return 207; +break; +case 133: return 207; +break; +case 134: return 207; +break; +case 135: return 191; +break; +case 136: return 103; +break; +case 137: return 200; +break; +case 138: return 200; +break; +case 139: return 200; +break; +case 140: return 200; +break; +case 141: return 200; +break; +case 142: return 200; +break; +case 143: return 17; +break; +case 144: return 192; +break; +case 145: return ':'; +break; +case 146: return 177; +break; +case 147: return 198; +break; +case 148: return 190; +break; +case 149: return 7; +break; +case 150: return 8; +break; +case 151: return 196; +break; +case 152: return 197; +break; +case 153: return 77; +break; +case 154: this.begin('backtickedValue'); return 201; +break; +case 155: + if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '`')) { + return 257; + } + return 255; + +break; +case 156: this.popState(); return 201; +break; +case 157: this.begin('singleQuotedValue'); return 237; +break; +case 158: + if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '\'')) { + return 257; + } + return 255; + +break; +case 159: this.popState(); return 237; +break; +case 160: this.begin('doubleQuotedValue'); return 212; +break; +case 161: + if (parser.handleQuotedValueWithCursor(this, yy_.yytext, yy_.yylloc, '"')) { + return 257; + } + return 255; + +break; +case 162: this.popState(); return 212; +break; +case 163: return 173; +break; +case 164: /* To prevent console logging of unknown chars */ +break; +case 165: +break; +case 166: +break; +case 167: +break; +case 168: +break; +case 169: +break; +case 170:console.log(yy_.yytext); +break; +} +}, +rules: [/^(?:\s)/i,/^(?:--.*)/i,/^(?:[/][*][^*]*[*]+([^/*][^*]*[*]+)*[/])/i,/^(?:\u2020)/i,/^(?:\u2021)/i,/^(?:AND)/i,/^(?:ALL)/i,/^(?:ALTER)/i,/^(?:AND)/i,/^(?:AS)/i,/^(?:ASC)/i,/^(?:BETWEEN)/i,/^(?:BIGINT)/i,/^(?:BOOLEAN)/i,/^(?:BY)/i,/^(?:CASCADE)/i,/^(?:CASE)/i,/^(?:CHAR)/i,/^(?:COLUMNS)/i,/^(?:COMMENT)/i,/^(?:CREATE)/i,/^(?:CROSS)/i,/^(?:CURRENT)/i,/^(?:DATABASE)/i,/^(?:DECIMAL)/i,/^(?:DESC)/i,/^(?:DISTINCT)/i,/^(?:DIV)/i,/^(?:DOUBLE)/i,/^(?:DROP)/i,/^(?:ELSE)/i,/^(?:END)/i,/^(?:EXISTS)/i,/^(?:FALSE)/i,/^(?:FLOAT)/i,/^(?:FOLLOWING)/i,/^(?:FROM)/i,/^(?:FULL)/i,/^(?:GROUP)/i,/^(?:HAVING)/i,/^(?:IF)/i,/^(?:IN)/i,/^(?:INNER)/i,/^(?:INSERT)/i,/^(?:INT)/i,/^(?:INTO)/i,/^(?:IS)/i,/^(?:JOIN)/i,/^(?:LEFT)/i,/^(?:LIKE)/i,/^(?:LIMIT)/i,/^(?:NOT)/i,/^(?:NULL)/i,/^(?:ON)/i,/^(?:OPTION)/i,/^(?:OR)/i,/^(?:ORDER)/i,/^(?:OUTER)/i,/^(?:PARTITION)/i,/^(?:PRECEDING)/i,/^(?:PURGE)/i,/^(?:RANGE)/i,/^(?:REGEXP)/i,/^(?:RIGHT)/i,/^(?:RLIKE)/i,/^(?:ROW)/i,/^(?:ROLE)/i,/^(?:ROWS)/i,/^(?:SCHEMA)/i,/^(?:SCHEMAS)/i,/^(?:SELECT)/i,/^(?:SEMI)/i,/^(?:SET)/i,/^(?:SHOW)/i,/^(?:SMALLINT)/i,/^(?:STRING)/i,/^(?:TABLE)/i,/^(?:TABLES)/i,/^(?:THEN)/i,/^(?:TIMESTAMP)/i,/^(?:TINYINT)/i,/^(?:TO)/i,/^(?:TRUE)/i,/^(?:TRUNCATE)/i,/^(?:UNBOUNDED)/i,/^(?:UNION)/i,/^(?:UPDATE)/i,/^(?:USE)/i,/^(?:VALUES)/i,/^(?:VARCHAR)/i,/^(?:VIEW)/i,/^(?:WHEN)/i,/^(?:WHERE)/i,/^(?:WITH)/i,/^(?:OVER)/i,/^(?:ROLE)/i,/^(?:AVG\s*\()/i,/^(?:CAST\s*\()/i,/^(?:COUNT\s*\()/i,/^(?:MAX\s*\()/i,/^(?:MIN\s*\()/i,/^(?:STDDEV_POP\s*\()/i,/^(?:STDDEV_SAMP\s*\()/i,/^(?:SUM\s*\()/i,/^(?:VAR_POP\s*\()/i,/^(?:VAR_SAMP\s*\()/i,/^(?:VARIANCE\s*\()/i,/^(?:CUME_DIST\s*\()/i,/^(?:DENSE_RANK\s*\()/i,/^(?:FIRST_VALUE\s*\()/i,/^(?:LAG\s*\()/i,/^(?:LAST_VALUE\s*\()/i,/^(?:LEAD\s*\()/i,/^(?:RANK\s*\()/i,/^(?:ROW_NUMBER\s*\()/i,/^(?:[0-9]+)/i,/^(?:[0-9]+(?:[YSL]|BD)?)/i,/^(?:[0-9]+E)/i,/^(?:[A-Za-z0-9_]+)/i,/^(?:\u2020)/i,/^(?:\u2021)/i,/^(?:\s+['"])/i,/^(?:[^'"\u2020\u2021]+)/i,/^(?:['"])/i,/^(?:$)/i,/^(?:&&)/i,/^(?:\|\|)/i,/^(?:=)/i,/^(?:<)/i,/^(?:>)/i,/^(?:!=)/i,/^(?:<=)/i,/^(?:>=)/i,/^(?:<>)/i,/^(?:<=>)/i,/^(?:-)/i,/^(?:\*)/i,/^(?:\+)/i,/^(?:\/)/i,/^(?:%)/i,/^(?:\|)/i,/^(?:\^)/i,/^(?:&)/i,/^(?:,)/i,/^(?:\.)/i,/^(?::)/i,/^(?:;)/i,/^(?:~)/i,/^(?:!)/i,/^(?:\()/i,/^(?:\))/i,/^(?:\[)/i,/^(?:\])/i,/^(?:\$\{[^}]*\})/i,/^(?:`)/i,/^(?:[^`]+)/i,/^(?:`)/i,/^(?:')/i,/^(?:(?:\\\\|\\[']|[^'])+)/i,/^(?:')/i,/^(?:")/i,/^(?:(?:\\\\|\\["]|[^"])+)/i,/^(?:")/i,/^(?:$)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i,/^(?:.)/i], +conditions: {"hdfs":{"rules":[119,120,121,122,123,124,166],"inclusive":false},"doubleQuotedValue":{"rules":[161,162,169],"inclusive":false},"singleQuotedValue":{"rules":[158,159,168],"inclusive":false},"backtickedValue":{"rules":[155,156,167],"inclusive":false},"between":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,157,160,163,164,165,170],"inclusive":true},"INITIAL":{"rules":[0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,157,160,163,164,170],"inclusive":true}} +}); +return lexer; +})(); +parser.lexer = lexer; +function Parser () { + this.yy = {}; +} +Parser.prototype = parser;parser.Parser = Parser; +return new Parser; +})(); +export default sparksqlSyntaxParser; diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.test.js b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.test.js new file mode 100644 index 00000000000..bb13ea8c3af --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/sparksqlSyntaxParser.test.js @@ -0,0 +1,179 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// 'License'); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an 'AS IS' BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import sparksqlSyntaxParser from './sparksqlSyntaxParser'; + +describe('sparksqlSyntaxParser.js', () => { + const expectedToStrings = function (expected) { + return expected.map(ex => ex.text); + }; + + it('should not find errors for ""', () => { + const result = sparksqlSyntaxParser.parseSyntax('', ''); + + expect(result).toBeFalsy(); + }); + + it('should report incomplete statement for "SEL"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SEL', ''); + + expect(result.incompleteStatement).toBeTruthy(); + }); + + it('should report incomplete statement for "SELECT"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT', ''); + + expect(result.incompleteStatement).toBeTruthy(); + }); + + it('should report incomplete statement for "SELECT "', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT ', ''); + + expect(result.incompleteStatement).toBeTruthy(); + }); + + it('should not report incomplete statement for "SELECT * FROM tbl"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT * FROM tbl', ''); + + expect(result.incompleteStatement).toBeFalsy(); + }); + + it('should not report incomplete statement for "SELECT * FROM tbl LIMIT 1"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT * FROM tbl LIMIT 1', ''); + + expect(result.incompleteStatement).toBeFalsy(); + }); + + it('should report incomplete statement for "SELECT * FROM tbl LIMIT "', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT * FROM tbl LIMIT ', ''); + + expect(result.incompleteStatement).toBeTruthy(); + }); + + it('should report incomplete statement for "SELECT * FROM tbl GROUP"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT * FROM tbl GROUP', ''); + + expect(result.incompleteStatement).toBeTruthy(); + }); + + it('should not find errors for "SELECT *"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT *', ''); + + expect(result).toBeFalsy(); + }); + + it('should not report incomplete statement for "SELECT * FR"', () => { + const result = sparksqlSyntaxParser.parseSyntax('SELECT * FR', ''); + + expect(result.incompleteStatement).toBeTruthy(); + }); + + it('should find errors for "SLELECT "', () => { + const result = sparksqlSyntaxParser.parseSyntax('SLELECT ', ''); + + expect(result).toBeTruthy(); + expect(result.text).toEqual('SLELECT'); + expect(result.expected.length).toBeGreaterThan(0); + expect(result.loc.first_column).toEqual(0); + expect(result.loc.last_column).toEqual(7); + }); + + xit('should find errors for "alter tabel "', () => { + const result = sparksqlSyntaxParser.parseSyntax('alter tabel ', ''); + + expect(result).toBeTruthy(); + expect(result.text).toEqual('tabel'); + expect(result.expected.length).toBeGreaterThan(0); + expect(result.loc.first_column).toEqual(6); + expect(result.loc.last_column).toEqual(11); + }); + + it('should find errors for "select * form "', () => { + const result = sparksqlSyntaxParser.parseSyntax('select * form ', ''); + + expect(result).toBeTruthy(); + expect(result.loc.first_column).toEqual(10); + expect(result.loc.last_column).toEqual(14); + expect(expectedToStrings(result.expected)).toEqual(['from', 'union']); + }); + + it('should find errors for "select * from customers c cultster by awasd asd afd;"', () => { + const result = sparksqlSyntaxParser.parseSyntax( + 'select * from customers c cultster by awasd asd afd;', + '' + ); + + expect(result).toBeTruthy(); + }); + + it('should find errors for "select asdf wer qwer qewr qwer"', () => { + const result = sparksqlSyntaxParser.parseSyntax('select asdf wer qwer qewr qwer', ''); + + expect(result).toBeTruthy(); + }); + + it('should suggest expected words for "SLELECT "', () => { + const result = sparksqlSyntaxParser.parseSyntax('SLELECT ', ''); + + expect(result).toBeTruthy(); + expect(expectedToStrings(result.expected).indexOf('SELECT')).not.toEqual(-1); + }); + + it('should suggest expected words for "slelect "', () => { + const result = sparksqlSyntaxParser.parseSyntax('slelect ', ''); + + expect(result).toBeTruthy(); + expect(expectedToStrings(result.expected).indexOf('select')).not.toEqual(-1); + }); + + const expectEqualIds = function (beforeA, afterA, beforeB, afterB) { + const resultA = sparksqlSyntaxParser.parseSyntax(beforeA, afterA); + const resultB = sparksqlSyntaxParser.parseSyntax(beforeB, afterB); + + expect(resultA).toBeTruthy(); + expect(resultB).toBeTruthy(); + expect(resultA.ruleId).toEqual(resultB.ruleId); + }; + + const expectNonEqualIds = function (beforeA, afterA, beforeB, afterB) { + const resultA = sparksqlSyntaxParser.parseSyntax(beforeA, afterA); + const resultB = sparksqlSyntaxParser.parseSyntax(beforeB, afterB); + + expect(resultA).toBeTruthy(); + expect(resultB).toBeTruthy(); + expect(resultA.ruleId).not.toEqual(resultB.ruleId); + }; + + it('should have unique rule IDs when the same rule is failing in different locations', () => { + expectEqualIds('SLELECT ', '', 'dlrop ', ''); + expectEqualIds('SELECT * FORM ', '', 'SELECT * bla ', ''); + expectEqualIds('DROP TABLE b.bla ERRROROR ', '', 'DROP TABLE c.cla OTHERERRRRORRR ', ''); + expectEqualIds( + 'SELECT * FROM a WHERE id = 1, a b SELECT ', + '', + 'SELECT id, foo FROM a WHERE a b SELECT', + '' + ); + expectEqualIds( + 'SELECT * FROM a WHERE id = 1, a b SELECT ', + '', + 'SELECT id, foo FROM a WHERE a b SELECT', + '' + ); + + expectNonEqualIds('slelect ', '', 'select * form ', ''); + }); +}); diff --git a/desktop/core/src/desktop/js/parse/sql/sparksql/sqlParseSupport.js b/desktop/core/src/desktop/js/parse/sql/sparksql/sqlParseSupport.js new file mode 100644 index 00000000000..10e88a74707 --- /dev/null +++ b/desktop/core/src/desktop/js/parse/sql/sparksql/sqlParseSupport.js @@ -0,0 +1,1445 @@ +// Licensed to Cloudera, Inc. under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. Cloudera, Inc. licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import { matchesType } from 'sql/reference/typeUtils'; +import { + initSharedAutocomplete, + initSyntaxParser, + identifierEquals, + equalIgnoreCase, + SIMPLE_TABLE_REF_SUGGESTIONS, + adjustForPartialBackticks +} from 'parse/sql/sqlParseUtils'; + +const initSqlParser = function (parser) { + initSharedAutocomplete(parser); + + parser.prepareNewStatement = function () { + linkTablePrimaries(); + parser.commitLocations(); + + delete parser.yy.latestCommonTableExpressions; + delete parser.yy.correlatedSubQuery; + parser.yy.subQueries = []; + parser.yy.selectListAliases = []; + parser.yy.latestTablePrimaries = []; + + prioritizeSuggestions(); + }; + + parser.yy.parseError = function (message, error) { + parser.yy.errors.push(error); + return message; + }; + + parser.addCommonTableExpressions = function (identifiers) { + parser.yy.result.commonTableExpressions = identifiers; + parser.yy.latestCommonTableExpressions = identifiers; + }; + + parser.isInSubquery = function () { + return !!parser.yy.primariesStack.length; + }; + + parser.pushQueryState = function () { + parser.yy.resultStack.push(parser.yy.result); + parser.yy.locationsStack.push(parser.yy.locations); + parser.yy.selectListAliasesStack.push(parser.yy.selectListAliases); + parser.yy.primariesStack.push(parser.yy.latestTablePrimaries); + parser.yy.subQueriesStack.push(parser.yy.subQueries); + + parser.yy.result = {}; + parser.yy.locations = []; + parser.yy.selectListAliases = []; // Not allowed in correlated sub-queries + + if (parser.yy.correlatedSubQuery) { + parser.yy.latestTablePrimaries = parser.yy.latestTablePrimaries.concat(); + parser.yy.subQueries = parser.yy.subQueries.concat(); + } else { + parser.yy.latestTablePrimaries = []; + parser.yy.subQueries = []; + } + }; + + parser.popQueryState = function (subQuery) { + linkTablePrimaries(); + parser.commitLocations(); + + if (Object.keys(parser.yy.result).length === 0) { + parser.yy.result = parser.yy.resultStack.pop(); + } else { + parser.yy.resultStack.pop(); + } + const oldSubQueries = parser.yy.subQueries; + parser.yy.subQueries = parser.yy.subQueriesStack.pop(); + if (subQuery) { + if (oldSubQueries.length > 0) { + subQuery.subQueries = oldSubQueries; + } + parser.yy.subQueries.push(subQuery); + } + + parser.yy.latestTablePrimaries = parser.yy.primariesStack.pop(); + parser.yy.locations = parser.yy.locationsStack.pop(); + parser.yy.selectListAliases = parser.yy.selectListAliasesStack.pop(); + }; + + parser.suggestSelectListAliases = function () { + if ( + parser.yy.selectListAliases && + parser.yy.selectListAliases.length > 0 && + parser.yy.result.suggestColumns && + (typeof parser.yy.result.suggestColumns.identifierChain === 'undefined' || + parser.yy.result.suggestColumns.identifierChain.length === 0) + ) { + parser.yy.result.suggestColumnAliases = parser.yy.selectListAliases; + } + }; + + parser.mergeSuggestKeywords = function () { + let result = []; + Array.prototype.slice.call(arguments).forEach(suggestion => { + if (typeof suggestion !== 'undefined' && typeof suggestion.suggestKeywords !== 'undefined') { + result = result.concat(suggestion.suggestKeywords); + } + }); + if (result.length > 0) { + return { suggestKeywords: result }; + } + return {}; + }; + + parser.suggestValueExpressionKeywords = function (valueExpression, extras) { + const expressionKeywords = parser.getValueExpressionKeywords(valueExpression, extras); + parser.suggestKeywords(expressionKeywords.suggestKeywords); + if (expressionKeywords.suggestColRefKeywords) { + parser.suggestColRefKeywords(expressionKeywords.suggestColRefKeywords); + } + if (valueExpression.lastType) { + parser.addColRefIfExists(valueExpression.lastType); + } else { + parser.addColRefIfExists(valueExpression); + } + }; + + parser.getSelectListKeywords = function (excludeAsterisk) { + const keywords = [{ value: 'CASE', weight: 450 }, 'FALSE', 'TRUE', 'NULL']; + if (!excludeAsterisk) { + keywords.push({ value: '*', weight: 10000 }); + } + return keywords; + }; + + parser.getValueExpressionKeywords = function (valueExpression, extras) { + const types = valueExpression.lastType ? valueExpression.lastType.types : valueExpression.types; + // We could have valueExpression.columnReference to suggest based on column type + let keywords = [ + '<', + '<=', + '<=>', + '<>', + '=', + '>', + '>=', + 'BETWEEN', + 'IN', + 'IS NOT NULL', + 'IS NULL', + 'IS NOT TRUE', + 'IS TRUE', + 'IS NOT FALSE', + 'IS FALSE', + 'NOT BETWEEN', + 'NOT IN' + ]; + if (extras) { + keywords = keywords.concat(extras); + } + if (valueExpression.suggestKeywords) { + keywords = keywords.concat(valueExpression.suggestKeywords); + } + if (types.length === 1 && types[0] === 'COLREF') { + return { + suggestKeywords: keywords, + suggestColRefKeywords: { + BOOLEAN: ['AND', 'OR'], + NUMBER: ['+', '-', '*', '/', '%', 'DIV'], + STRING: ['LIKE', 'NOT LIKE', 'REGEXP', 'RLIKE'] + } + }; + } + if (matchesType(parser.yy.activeDialect, ['BOOLEAN'], types)) { + keywords = keywords.concat(['AND', 'OR']); + } + if (matchesType(parser.yy.activeDialect, ['NUMBER'], types)) { + keywords = keywords.concat(['+', '-', '*', '/', '%', 'DIV']); + } + if (matchesType(parser.yy.activeDialect, ['STRING'], types)) { + keywords = keywords.concat(['LIKE', 'NOT LIKE', 'REGEXP', 'RLIKE']); + } + return { suggestKeywords: keywords }; + }; + + parser.getTypeKeywords = function () { + return [ + 'BIGINT', + 'BOOLEAN', + 'CHAR', + 'DECIMAL', + 'DOUBLE', + 'FLOAT', + 'INT', + 'SMALLINT', + 'TIMESTAMP', + 'STRING', + 'TINYINT', + 'VARCHAR' + ]; + }; + + parser.getColumnDataTypeKeywords = function () { + return parser.getTypeKeywords(); + }; + + parser.addColRefIfExists = function (valueExpression) { + if (valueExpression.columnReference) { + parser.yy.result.colRef = { identifierChain: valueExpression.columnReference }; + } + }; + + parser.selectListNoTableSuggest = function (selectListEdit, hasDistinctOrAll) { + if (selectListEdit.cursorAtStart) { + let keywords = parser.getSelectListKeywords(); + if (!hasDistinctOrAll) { + keywords = keywords.concat([ + { value: 'ALL', weight: 2 }, + { value: 'DISTINCT', weight: 2 } + ]); + } + parser.suggestKeywords(keywords); + } else { + parser.checkForKeywords(selectListEdit); + } + if (selectListEdit.suggestFunctions) { + parser.suggestFunctions(); + } + if (selectListEdit.suggestColumns) { + parser.suggestColumns(); + } + if ( + selectListEdit.suggestAggregateFunctions && + (!hasDistinctOrAll || hasDistinctOrAll === 'ALL') + ) { + parser.suggestAggregateFunctions(); + parser.suggestAnalyticFunctions(); + } + }; + + parser.suggestJoinConditions = function (details) { + parser.yy.result.suggestJoinConditions = details || {}; + if (parser.yy.latestTablePrimaries && !parser.yy.result.suggestJoinConditions.tablePrimaries) { + parser.yy.result.suggestJoinConditions.tablePrimaries = + parser.yy.latestTablePrimaries.concat(); + } + }; + + parser.suggestJoins = function (details) { + parser.yy.result.suggestJoins = details || {}; + }; + + parser.findCaseType = function (whenThenList) { + const types = {}; + whenThenList.caseTypes.forEach(valueExpression => { + valueExpression.types.forEach(type => { + types[type] = true; + }); + }); + if (Object.keys(types).length === 1) { + return { types: [Object.keys(types)[0]] }; + } + return { types: ['T'] }; + }; + + parser.applyArgumentTypesToSuggestions = function (functionName, position) { + if (parser.yy.result.suggestFunctions || parser.yy.result.suggestColumns) { + parser.yy.result.udfArgument = { + name: functionName.toLowerCase(), + position: position + }; + } + }; + + parser.commitLocations = function () { + if (parser.yy.locations.length === 0) { + return; + } + + const tablePrimaries = parser.yy.latestTablePrimaries; + + let i = parser.yy.locations.length; + + while (i--) { + const location = parser.yy.locations[i]; + if (location.type === 'variable' && location.colRef) { + parser.expandIdentifierChain({ + wrapper: location.colRef, + tablePrimaries: tablePrimaries, + isColumnWrapper: true + }); + delete location.colRef.linked; + } + + if (location.type === 'unknown') { + if ( + typeof location.identifierChain !== 'undefined' && + location.identifierChain.length > 0 && + location.identifierChain.length <= 2 && + tablePrimaries + ) { + let found = tablePrimaries.filter(primary => { + return ( + equalIgnoreCase(primary.alias, location.identifierChain[0].name) || + (primary.identifierChain && + equalIgnoreCase(primary.identifierChain[0].name, location.identifierChain[0].name)) + ); + }); + if (!found.length && location.firstInChain) { + found = tablePrimaries.filter(primary => { + return ( + !primary.alias && + primary.identifierChain && + equalIgnoreCase( + primary.identifierChain[primary.identifierChain.length - 1].name, + location.identifierChain[0].name + ) + ); + }); + } + + if (found.length) { + if ( + found[0].identifierChain.length > 1 && + location.identifierChain.length === 1 && + equalIgnoreCase(found[0].identifierChain[0].name, location.identifierChain[0].name) + ) { + location.type = 'database'; + } else if ( + found[0].alias && + equalIgnoreCase(location.identifierChain[0].name, found[0].alias) && + location.identifierChain.length > 1 + ) { + location.type = 'column'; + parser.expandIdentifierChain({ + tablePrimaries: tablePrimaries, + wrapper: location, + anyOwner: true + }); + } else if ( + !found[0].alias && + found[0].identifierChain && + equalIgnoreCase( + location.identifierChain[0].name, + found[0].identifierChain[found[0].identifierChain.length - 1].name + ) && + location.identifierChain.length > 1 + ) { + location.type = 'column'; + parser.expandIdentifierChain({ + tablePrimaries: tablePrimaries, + wrapper: location, + anyOwner: true + }); + } else { + location.type = 'table'; + parser.expandIdentifierChain({ + tablePrimaries: tablePrimaries, + wrapper: location, + anyOwner: true + }); + } + } else if (parser.yy.subQueries) { + found = parser.yy.subQueries.filter(subQuery => { + return equalIgnoreCase(subQuery.alias, location.identifierChain[0].name); + }); + if (found.length > 0) { + location.type = 'subQuery'; + location.identifierChain = [{ subQuery: found[0].alias }]; + } + } + } + } + + if (location.type === 'asterisk' && !location.linked) { + if (tablePrimaries && tablePrimaries.length > 0) { + location.tables = []; + location.linked = false; + if (!location.identifierChain) { + location.identifierChain = [{ asterisk: true }]; + } + parser.expandIdentifierChain({ + tablePrimaries: tablePrimaries, + wrapper: location, + anyOwner: false + }); + if (location.tables.length === 0) { + parser.yy.locations.splice(i, 1); + } + } else { + parser.yy.locations.splice(i, 1); + } + } + + if ( + location.type === 'table' && + typeof location.identifierChain !== 'undefined' && + location.identifierChain.length === 1 && + location.identifierChain[0].name + ) { + // Could be a cte reference + parser.yy.locations.some(otherLocation => { + if ( + otherLocation.type === 'alias' && + otherLocation.source === 'cte' && + identifierEquals(otherLocation.alias, location.identifierChain[0].name) + ) { + // TODO: Possibly add the other location if we want to show the link in the future. + // i.e. highlight select definition on hover over alias, also for subquery references. + location.type = 'alias'; + location.target = 'cte'; + location.alias = location.identifierChain[0].name; + delete location.identifierChain; + return true; + } + }); + } + + if ( + location.type === 'table' && + (typeof location.identifierChain === 'undefined' || location.identifierChain.length === 0) + ) { + parser.yy.locations.splice(i, 1); + } + + if (location.type === 'unknown') { + location.type = 'column'; + } + + // A column location might refer to a previously defined alias, i.e. last 'foo' in "SELECT cast(id AS int) foo FROM tbl ORDER BY foo;" + if (location.type === 'column') { + for (let j = i - 1; j >= 0; j--) { + const otherLocation = parser.yy.locations[j]; + if ( + otherLocation.type === 'alias' && + otherLocation.source === 'column' && + location.identifierChain && + location.identifierChain.length === 1 && + location.identifierChain[0].name && + otherLocation.alias && + location.identifierChain[0].name.toLowerCase() === otherLocation.alias.toLowerCase() + ) { + location.type = 'alias'; + location.source = 'column'; + location.alias = location.identifierChain[0].name; + delete location.identifierChain; + location.parentLocation = otherLocation.parentLocation; + break; + } + } + } + + if (location.type === 'column') { + const initialIdentifierChain = location.identifierChain + ? location.identifierChain.concat() + : undefined; + + parser.expandIdentifierChain({ + tablePrimaries: tablePrimaries, + wrapper: location, + anyOwner: true, + isColumnWrapper: true, + isColumnLocation: true + }); + + if (typeof location.identifierChain === 'undefined') { + parser.yy.locations.splice(i, 1); + } else if ( + location.identifierChain.length === 0 && + initialIdentifierChain && + initialIdentifierChain.length === 1 + ) { + // This is for the case "SELECT tblOrColName FROM db.tblOrColName"; + location.identifierChain = initialIdentifierChain; + } + } + if (location.type === 'column' && location.identifierChain) { + if (location.identifierChain.length > 1 && location.tables && location.tables.length > 0) { + location.type = 'complex'; + } + } + delete location.firstInChain; + if (location.type !== 'column' && location.type !== 'complex') { + delete location.qualified; + } else if (typeof location.qualified === 'undefined') { + location.qualified = false; + } + } + + if (parser.yy.locations.length > 0) { + parser.yy.allLocations = parser.yy.allLocations.concat(parser.yy.locations); + parser.yy.locations = []; + } + }; + + const prioritizeSuggestions = function () { + parser.yy.result.lowerCase = parser.yy.lowerCase || false; + + const cteIndex = {}; + + if (typeof parser.yy.latestCommonTableExpressions !== 'undefined') { + parser.yy.latestCommonTableExpressions.forEach(cte => { + cteIndex[cte.alias.toLowerCase()] = cte; + }); + } + + SIMPLE_TABLE_REF_SUGGESTIONS.forEach(suggestionType => { + if ( + suggestionType !== 'suggestAggregateFunctions' && + typeof parser.yy.result[suggestionType] !== 'undefined' && + parser.yy.result[suggestionType].tables.length === 0 + ) { + delete parser.yy.result[suggestionType]; + } else if ( + typeof parser.yy.result[suggestionType] !== 'undefined' && + typeof parser.yy.result[suggestionType].tables !== 'undefined' + ) { + for (let i = parser.yy.result[suggestionType].tables.length - 1; i >= 0; i--) { + const table = parser.yy.result[suggestionType].tables[i]; + if ( + table.identifierChain.length === 1 && + typeof table.identifierChain[0].name !== 'undefined' && + typeof cteIndex[table.identifierChain[0].name.toLowerCase()] !== 'undefined' + ) { + parser.yy.result[suggestionType].tables.splice(i, 1); + } + } + } + }); + + if (typeof parser.yy.result.colRef !== 'undefined') { + if ( + !parser.yy.result.colRef.linked || + typeof parser.yy.result.colRef.identifierChain === 'undefined' || + parser.yy.result.colRef.identifierChain.length === 0 + ) { + delete parser.yy.result.colRef; + if (typeof parser.yy.result.suggestColRefKeywords !== 'undefined') { + Object.keys(parser.yy.result.suggestColRefKeywords).forEach(type => { + parser.yy.result.suggestKeywords = parser.yy.result.suggestKeywords.concat( + parser.createWeightedKeywords(parser.yy.result.suggestColRefKeywords[type], -1) + ); + }); + delete parser.yy.result.suggestColRefKeywords; + } + if ( + parser.yy.result.suggestColumns && + parser.yy.result.suggestColumns.types.length === 1 && + parser.yy.result.suggestColumns.types[0] === 'COLREF' + ) { + parser.yy.result.suggestColumns.types = ['T']; + } + delete parser.yy.result.suggestValues; + } + } + + if (typeof parser.yy.result.colRef !== 'undefined') { + if ( + !parser.yy.result.suggestValues && + !parser.yy.result.suggestColRefKeywords && + (!parser.yy.result.suggestColumns || parser.yy.result.suggestColumns.types[0] !== 'COLREF') + ) { + delete parser.yy.result.colRef; + } + } + if ( + typeof parser.yy.result.suggestIdentifiers !== 'undefined' && + parser.yy.result.suggestIdentifiers.length > 0 + ) { + delete parser.yy.result.suggestTables; + delete parser.yy.result.suggestDatabases; + } + if (typeof parser.yy.result.suggestColumns !== 'undefined') { + const suggestColumns = parser.yy.result.suggestColumns; + if (typeof suggestColumns.tables === 'undefined' || suggestColumns.tables.length === 0) { + delete parser.yy.result.suggestColumns; + delete parser.yy.result.subQueries; + } else { + delete parser.yy.result.suggestTables; + delete parser.yy.result.suggestDatabases; + + suggestColumns.tables.forEach(table => { + if ( + typeof table.identifierChain !== 'undefined' && + table.identifierChain.length === 1 && + typeof table.identifierChain[0].name !== 'undefined' + ) { + const cte = cteIndex[table.identifierChain[0].name.toLowerCase()]; + if (typeof cte !== 'undefined') { + delete table.identifierChain[0].name; + table.identifierChain[0].cte = cte.alias; + } + } else if (typeof table.identifierChain === 'undefined' && table.subQuery) { + table.identifierChain = [{ subQuery: table.subQuery }]; + delete table.subQuery; + } + }); + + if ( + typeof suggestColumns.identifierChain !== 'undefined' && + suggestColumns.identifierChain.length === 0 + ) { + delete suggestColumns.identifierChain; + } + } + } else { + delete parser.yy.result.subQueries; + } + + if (typeof parser.yy.result.suggestJoinConditions !== 'undefined') { + if ( + typeof parser.yy.result.suggestJoinConditions.tables === 'undefined' || + parser.yy.result.suggestJoinConditions.tables.length === 0 + ) { + delete parser.yy.result.suggestJoinConditions; + } + } + + if ( + typeof parser.yy.result.suggestTables !== 'undefined' && + typeof parser.yy.result.commonTableExpressions !== 'undefined' + ) { + const ctes = []; + parser.yy.result.commonTableExpressions.forEach(cte => { + const suggestion = { name: cte.alias }; + if (parser.yy.result.suggestTables.prependFrom) { + suggestion.prependFrom = true; + } + if (parser.yy.result.suggestTables.prependQuestionMark) { + suggestion.prependQuestionMark = true; + } + ctes.push(suggestion); + }); + if (ctes.length > 0) { + parser.yy.result.suggestCommonTableExpressions = ctes; + } + } + }; + + const addCleanTablePrimary = function (tables, tablePrimary) { + if (tablePrimary.alias) { + tables.push({ alias: tablePrimary.alias, identifierChain: tablePrimary.identifierChain }); + } else { + tables.push({ identifierChain: tablePrimary.identifierChain }); + } + }; + + parser.expandIdentifierChain = function (options) { + const wrapper = options.wrapper; + const anyOwner = options.anyOwner; + const isColumnWrapper = options.isColumnWrapper; + const isColumnLocation = options.isColumnLocation; + let tablePrimaries = options.tablePrimaries || parser.yy.latestTablePrimaries; + + if (typeof wrapper.identifierChain === 'undefined' || typeof tablePrimaries === 'undefined') { + return; + } + let identifierChain = wrapper.identifierChain.concat(); + + if (tablePrimaries.length === 0) { + delete wrapper.identifierChain; + return; + } + + if (!anyOwner) { + tablePrimaries = filterTablePrimariesForOwner(tablePrimaries, wrapper.owner); + } + + if (identifierChain.length > 0 && identifierChain[identifierChain.length - 1].asterisk) { + const tables = []; + tablePrimaries.forEach(tablePrimary => { + if (identifierChain.length > 1 && !tablePrimary.subQueryAlias) { + if ( + identifierChain.length === 2 && + equalIgnoreCase(tablePrimary.alias, identifierChain[0].name) + ) { + addCleanTablePrimary(tables, tablePrimary); + } else if ( + identifierChain.length === 2 && + equalIgnoreCase(tablePrimary.identifierChain[0].name, identifierChain[0].name) + ) { + addCleanTablePrimary(tables, tablePrimary); + } else if ( + identifierChain.length === 3 && + tablePrimary.identifierChain.length > 1 && + equalIgnoreCase(tablePrimary.identifierChain[0].name, identifierChain[0].name) && + equalIgnoreCase(tablePrimary.identifierChain[1].name, identifierChain[1].name) + ) { + addCleanTablePrimary(tables, tablePrimary); + } + } else if (tablePrimary.subQueryAlias) { + tables.push({ identifierChain: [{ subQuery: tablePrimary.subQueryAlias }] }); + } else { + addCleanTablePrimary(tables, tablePrimary); + } + }); + // Possible Joins + if (tables.length > 0) { + wrapper.tables = tables; + delete wrapper.identifierChain; + return; + } + } + + // IdentifierChain contains a possibly started identifier or empty, example: a.b.c = ['a', 'b', 'c'] + // Reduce the tablePrimaries to the one that matches the first identifier if found + let foundPrimary; + let doubleMatch = false; + let aliasMatch = false; + if (identifierChain.length > 0) { + for (let i = 0; i < tablePrimaries.length; i++) { + if (tablePrimaries[i].subQueryAlias) { + if (equalIgnoreCase(tablePrimaries[i].subQueryAlias, identifierChain[0].name)) { + foundPrimary = tablePrimaries[i]; + } + } else if (equalIgnoreCase(tablePrimaries[i].alias, identifierChain[0].name)) { + foundPrimary = tablePrimaries[i]; + aliasMatch = true; + break; + } else if ( + tablePrimaries[i].identifierChain.length > 1 && + identifierChain.length > 1 && + equalIgnoreCase(tablePrimaries[i].identifierChain[0].name, identifierChain[0].name) && + equalIgnoreCase(tablePrimaries[i].identifierChain[1].name, identifierChain[1].name) + ) { + foundPrimary = tablePrimaries[i]; + doubleMatch = true; + break; + } else if ( + !foundPrimary && + equalIgnoreCase(tablePrimaries[i].identifierChain[0].name, identifierChain[0].name) && + identifierChain.length > (isColumnLocation ? 1 : 0) + ) { + foundPrimary = tablePrimaries[i]; + // No break as first two can still match. + } else if ( + !foundPrimary && + tablePrimaries[i].identifierChain.length > 1 && + !tablePrimaries[i].alias && + equalIgnoreCase( + tablePrimaries[i].identifierChain[tablePrimaries[i].identifierChain.length - 1].name, + identifierChain[0].name + ) + ) { + // This is for the case SELECT baa. FROM bla.baa, blo.boo; + foundPrimary = tablePrimaries[i]; + break; + } + } + } + + if (foundPrimary) { + identifierChain.shift(); + if (doubleMatch) { + identifierChain.shift(); + } + } else if (tablePrimaries.length === 1 && !isColumnWrapper) { + foundPrimary = tablePrimaries[0]; + } + + if (foundPrimary) { + if (isColumnWrapper) { + wrapper.identifierChain = identifierChain; + if (foundPrimary.subQueryAlias) { + wrapper.tables = [{ subQuery: foundPrimary.subQueryAlias }]; + } else if (foundPrimary.alias) { + if (!isColumnLocation && isColumnWrapper && aliasMatch) { + // TODO: add alias on table in suggestColumns (needs support in sqlAutocomplete3.js) + // the case is: SELECT cu.| FROM customers cu; + // This prevents alias from being added automatically in sqlAutocompleter.js + wrapper.tables = [{ identifierChain: foundPrimary.identifierChain }]; + } else { + wrapper.tables = [ + { identifierChain: foundPrimary.identifierChain, alias: foundPrimary.alias } + ]; + } + } else { + wrapper.tables = [{ identifierChain: foundPrimary.identifierChain }]; + } + } else { + if (foundPrimary.subQueryAlias) { + identifierChain.unshift({ subQuery: foundPrimary.subQueryAlias }); + } else { + identifierChain = foundPrimary.identifierChain.concat(identifierChain); + } + if (wrapper.tables) { + wrapper.tables.push({ identifierChain: identifierChain }); + delete wrapper.identifierChain; + } else { + wrapper.identifierChain = identifierChain; + } + } + } else { + if (isColumnWrapper) { + wrapper.tables = []; + } + tablePrimaries.forEach(tablePrimary => { + const targetTable = tablePrimary.subQueryAlias + ? { subQuery: tablePrimary.subQueryAlias } + : { identifierChain: tablePrimary.identifierChain }; + if (tablePrimary.alias) { + targetTable.alias = tablePrimary.alias; + } + if (wrapper.tables) { + wrapper.tables.push(targetTable); + } + }); + } + delete wrapper.owner; + wrapper.linked = true; + }; + + const filterTablePrimariesForOwner = function (tablePrimaries, owner) { + const result = []; + tablePrimaries.forEach(primary => { + if (typeof owner === 'undefined' && typeof primary.owner === 'undefined') { + result.push(primary); + } else if (owner === primary.owner) { + result.push(primary); + } + }); + return result; + }; + + const convertTablePrimariesToSuggestions = function (tablePrimaries) { + const tables = []; + const identifiers = []; + tablePrimaries.forEach(tablePrimary => { + if (tablePrimary.identifierChain && tablePrimary.identifierChain.length > 0) { + const table = { identifierChain: tablePrimary.identifierChain }; + if (tablePrimary.alias) { + table.alias = tablePrimary.alias; + identifiers.push({ name: table.alias + '.', type: 'alias' }); + } else { + const lastIdentifier = + tablePrimary.identifierChain[tablePrimary.identifierChain.length - 1]; + if (typeof lastIdentifier.name !== 'undefined') { + identifiers.push({ name: lastIdentifier.name + '.', type: 'table' }); + } else if (typeof lastIdentifier.subQuery !== 'undefined') { + identifiers.push({ name: lastIdentifier.subQuery + '.', type: 'sub-query' }); + } + } + tables.push(table); + } else if (tablePrimary.subQueryAlias) { + identifiers.push({ name: tablePrimary.subQueryAlias + '.', type: 'sub-query' }); + tables.push({ identifierChain: [{ subQuery: tablePrimary.subQueryAlias }] }); + } + }); + if (identifiers.length > 0) { + if (typeof parser.yy.result.suggestIdentifiers === 'undefined') { + parser.yy.result.suggestIdentifiers = identifiers; + } else { + parser.yy.result.suggestIdentifiers = identifiers.concat( + parser.yy.result.suggestIdentifiers + ); + } + } + parser.yy.result.suggestColumns.tables = tables; + if ( + parser.yy.result.suggestColumns.identifierChain && + parser.yy.result.suggestColumns.identifierChain.length === 0 + ) { + delete parser.yy.result.suggestColumns.identifierChain; + } + parser.yy.result.suggestColumns.linked = true; + }; + + const linkTablePrimaries = function () { + if (!parser.yy.cursorFound || typeof parser.yy.latestTablePrimaries === 'undefined') { + return; + } + + SIMPLE_TABLE_REF_SUGGESTIONS.forEach(suggestionType => { + if ( + typeof parser.yy.result[suggestionType] !== 'undefined' && + parser.yy.result[suggestionType].tablePrimaries && + !parser.yy.result[suggestionType].linked + ) { + parser.yy.result[suggestionType].tables = []; + parser.yy.result[suggestionType].tablePrimaries.forEach(tablePrimary => { + if (!tablePrimary.subQueryAlias) { + parser.yy.result[suggestionType].tables.push( + tablePrimary.alias + ? { + identifierChain: tablePrimary.identifierChain.concat(), + alias: tablePrimary.alias + } + : { identifierChain: tablePrimary.identifierChain.concat() } + ); + } + }); + delete parser.yy.result[suggestionType].tablePrimaries; + parser.yy.result[suggestionType].linked = true; + } + }); + + if ( + typeof parser.yy.result.suggestColumns !== 'undefined' && + !parser.yy.result.suggestColumns.linked + ) { + const tablePrimaries = filterTablePrimariesForOwner( + parser.yy.latestTablePrimaries, + parser.yy.result.suggestColumns.owner + ); + if (!parser.yy.result.suggestColumns.tables) { + parser.yy.result.suggestColumns.tables = []; + } + if (parser.yy.subQueries.length > 0) { + parser.yy.result.subQueries = parser.yy.subQueries; + } + if ( + typeof parser.yy.result.suggestColumns.identifierChain === 'undefined' || + parser.yy.result.suggestColumns.identifierChain.length === 0 + ) { + if (tablePrimaries.length > 1) { + convertTablePrimariesToSuggestions(tablePrimaries); + } else { + if ( + tablePrimaries.length === 1 && + (tablePrimaries[0].alias || tablePrimaries[0].subQueryAlias) + ) { + convertTablePrimariesToSuggestions(tablePrimaries); + } + parser.expandIdentifierChain({ + wrapper: parser.yy.result.suggestColumns, + anyOwner: false, + isColumnWrapper: true + }); + } + } else { + parser.expandIdentifierChain({ + wrapper: parser.yy.result.suggestColumns, + anyOwner: false, + isColumnWrapper: true + }); + } + } + + if (typeof parser.yy.result.colRef !== 'undefined' && !parser.yy.result.colRef.linked) { + parser.expandIdentifierChain({ wrapper: parser.yy.result.colRef }); + + const primaries = filterTablePrimariesForOwner(parser.yy.latestTablePrimaries); + if ( + primaries.length === 0 || + (primaries.length > 1 && parser.yy.result.colRef.identifierChain.length === 1) + ) { + parser.yy.result.colRef.identifierChain = []; + } + } + if ( + typeof parser.yy.result.suggestKeyValues !== 'undefined' && + !parser.yy.result.suggestKeyValues.linked + ) { + parser.expandIdentifierChain({ wrapper: parser.yy.result.suggestKeyValues }); + } + }; + + parser.addTablePrimary = function (ref) { + if (typeof parser.yy.latestTablePrimaries === 'undefined') { + parser.yy.latestTablePrimaries = []; + } + parser.yy.latestTablePrimaries.push(ref); + }; + + parser.suggestFileFormats = function () { + parser.suggestKeywords([ + 'AVRO', + 'KUDU', + 'ORC', + 'PARQUET', + 'RCFILE', + 'SEQUENCEFILE', + 'TEXTFILE' + ]); + }; + + parser.getKeywordsForOptionalsLR = function (optionals, keywords, override) { + let result = []; + + for (let i = 0; i < optionals.length; i++) { + if (!optionals[i] && (typeof override === 'undefined' || override[i])) { + if (keywords[i] instanceof Array) { + result = result.concat(keywords[i]); + } else { + result.push(keywords[i]); + } + } else if (optionals[i]) { + break; + } + } + return result; + }; + + parser.suggestDdlAndDmlKeywords = function (extraKeywords) { + let keywords = ['CREATE', 'DESCRIBE', 'SELECT', 'SHOW']; + + if (extraKeywords) { + keywords = keywords.concat(extraKeywords); + } + + parser.suggestKeywords(keywords); + }; + + parser.checkForSelectListKeywords = function (selectList) { + if (selectList.length === 0) { + return; + } + const last = selectList[selectList.length - 1]; + if (!last || !last.valueExpression) { + return; + } + const valueExpressionKeywords = parser.getValueExpressionKeywords(last.valueExpression); + let keywords = []; + if (last.suggestKeywords) { + keywords = keywords.concat(last.suggestKeywords); + } + if (valueExpressionKeywords.suggestKeywords) { + keywords = keywords.concat(valueExpressionKeywords.suggestKeywords); + } + if (valueExpressionKeywords.suggestColRefKeywords) { + parser.suggestColRefKeywords(valueExpressionKeywords.suggestColRefKeywords); + parser.addColRefIfExists(last.valueExpression); + } + if (!last.alias) { + keywords.push('AS'); + } + if (keywords.length > 0) { + parser.suggestKeywords(keywords); + } + }; + + parser.checkForKeywords = function (expression) { + if (expression) { + if (expression.suggestKeywords && expression.suggestKeywords.length > 0) { + parser.suggestKeywords(expression.suggestKeywords); + } + if (expression.suggestColRefKeywords) { + parser.suggestColRefKeywords(expression.suggestColRefKeywords); + parser.addColRefIfExists(expression); + } + } + }; + + parser.createWeightedKeywords = function (keywords, weight) { + const result = []; + keywords.forEach(keyword => { + if (typeof keyword.weight !== 'undefined') { + keyword.weight = weight + keyword.weight / 10; + result.push(keyword); + } else { + result.push({ value: keyword, weight: weight }); + } + }); + return result; + }; + + parser.suggestKeywords = function (keywords) { + const weightedKeywords = []; + if (keywords.length === 0) { + return; + } + keywords.forEach(keyword => { + if (typeof keyword.weight !== 'undefined') { + weightedKeywords.push(keyword); + } else { + weightedKeywords.push({ value: keyword, weight: -1 }); + } + }); + weightedKeywords.sort((a, b) => { + if (a.weight !== b.weight) { + return b.weight - a.weight; + } + return a.value.localeCompare(b.value); + }); + parser.yy.result.suggestKeywords = weightedKeywords; + }; + + parser.suggestColRefKeywords = function (colRefKeywords) { + parser.yy.result.suggestColRefKeywords = colRefKeywords; + }; + + parser.suggestTablesOrColumns = function (identifier) { + if (typeof parser.yy.latestTablePrimaries == 'undefined') { + parser.suggestTables({ identifierChain: [{ name: identifier }] }); + return; + } + const tableRef = parser.yy.latestTablePrimaries.filter(tablePrimary => { + return equalIgnoreCase(tablePrimary.alias, identifier); + }); + if (tableRef.length > 0) { + parser.suggestColumns({ identifierChain: [{ name: identifier }] }); + } else { + parser.suggestTables({ identifierChain: [{ name: identifier }] }); + } + }; + + parser.suggestFunctions = function (details) { + parser.yy.result.suggestFunctions = details || {}; + }; + + parser.suggestAggregateFunctions = function () { + const primaries = []; + const aliases = {}; + parser.yy.latestTablePrimaries.forEach(primary => { + if (typeof primary.alias !== 'undefined') { + aliases[primary.alias] = true; + } + // Drop if the first one refers to a table alias (...FROM tbl t, t.map tm ...) + if ( + typeof primary.identifierChain !== 'undefined' && + !aliases[primary.identifierChain[0].name] && + typeof primary.owner === 'undefined' + ) { + primaries.push(primary); + } + }); + parser.yy.result.suggestAggregateFunctions = { tablePrimaries: primaries }; + }; + + parser.suggestAnalyticFunctions = function () { + parser.yy.result.suggestAnalyticFunctions = true; + }; + + parser.suggestSetOptions = function () { + parser.yy.result.suggestSetOptions = true; + }; + + parser.suggestIdentifiers = function (identifiers) { + parser.yy.result.suggestIdentifiers = identifiers; + }; + + parser.suggestColumns = function (details) { + if (typeof details === 'undefined') { + details = { identifierChain: [] }; + } else if (typeof details.identifierChain === 'undefined') { + details.identifierChain = []; + } + parser.yy.result.suggestColumns = details; + }; + + parser.suggestGroupBys = function (details) { + parser.yy.result.suggestGroupBys = details || {}; + }; + + parser.suggestOrderBys = function (details) { + parser.yy.result.suggestOrderBys = details || {}; + }; + + parser.suggestFilters = function (details) { + parser.yy.result.suggestFilters = details || {}; + }; + + parser.suggestKeyValues = function (details) { + parser.yy.result.suggestKeyValues = details || {}; + }; + + parser.suggestTables = function (details) { + parser.yy.result.suggestTables = details || {}; + }; + + parser.firstDefined = function () { + for (let i = 0; i + 1 < arguments.length; i += 2) { + if (arguments[i]) { + return arguments[i + 1]; + } + } + }; + + parser.addColRefToVariableIfExists = function (left, right) { + if ( + left && + left.columnReference && + left.columnReference.length && + right && + right.columnReference && + right.columnReference.length && + parser.yy.locations.length > 1 + ) { + const addColRefToVariableLocation = function (variableValue, colRef) { + // See if colref is actually an alias + if (colRef.length === 1 && colRef[0].name) { + parser.yy.locations.some(location => { + if (location.type === 'column' && location.alias === colRef[0].name) { + colRef = location.identifierChain; + return true; + } + }); + } + + for (let i = parser.yy.locations.length - 1; i > 0; i--) { + const location = parser.yy.locations[i]; + if (location.type === 'variable' && location.value === variableValue) { + location.colRef = { identifierChain: colRef }; + break; + } + } + }; + + if (/\${[^}]*}/.test(left.columnReference[0].name)) { + // left is variable + addColRefToVariableLocation(left.columnReference[0].name, right.columnReference); + } else if (/\${[^}]*}/.test(right.columnReference[0].name)) { + // right is variable + addColRefToVariableLocation(right.columnReference[0].name, left.columnReference); + } + } + }; + + parser.suggestDatabases = function (details) { + parser.yy.result.suggestDatabases = details || {}; + }; + + parser.suggestHdfs = function (details) { + parser.yy.result.suggestHdfs = details || {}; + }; + + parser.suggestValues = function (details) { + parser.yy.result.suggestValues = details || {}; + }; + + parser.determineCase = function (text) { + if (!parser.yy.caseDetermined) { + parser.yy.lowerCase = text.toLowerCase() === text; + parser.yy.caseDetermined = true; + } + }; + + parser.handleQuotedValueWithCursor = function (lexer, yytext, yylloc, quoteChar) { + if (yytext.indexOf('\u2020') !== -1 || yytext.indexOf('\u2021') !== -1) { + parser.yy.partialCursor = yytext.indexOf('\u2021') !== -1; + const cursorIndex = parser.yy.partialCursor + ? yytext.indexOf('\u2021') + : yytext.indexOf('\u2020'); + parser.yy.cursorFound = { + first_line: yylloc.first_line, + last_line: yylloc.last_line, + first_column: yylloc.first_column + cursorIndex, + last_column: yylloc.first_column + cursorIndex + 1 + }; + const remainder = yytext.substring(cursorIndex + 1); + const remainingQuotes = (lexer.upcomingInput().match(new RegExp(quoteChar, 'g')) || []) + .length; + if (remainingQuotes > 0 && (remainingQuotes & 1) !== 0) { + parser.yy.missingEndQuote = false; + lexer.input(); + } else { + parser.yy.missingEndQuote = true; + lexer.unput(remainder); + } + lexer.popState(); + return true; + } + return false; + }; + + let lexerModified = false; + + /** + * Main parser function + */ + parser.parseSql = function (beforeCursor, afterCursor, debug) { + // Jison counts CRLF as two lines in the locations + beforeCursor = beforeCursor.replace(/\r\n|\n\r/gm, '\n'); + afterCursor = afterCursor.replace(/\r\n|\n\r/gm, '\n'); + parser.yy.result = { locations: [] }; + parser.yy.lowerCase = false; + parser.yy.locations = []; + parser.yy.definitions = []; + parser.yy.allLocations = []; + parser.yy.subQueries = []; + parser.yy.errors = []; + parser.yy.selectListAliases = []; + parser.yy.activeDialect = 'generic'; + + parser.yy.locationsStack = []; + parser.yy.primariesStack = []; + parser.yy.subQueriesStack = []; + parser.yy.resultStack = []; + parser.yy.selectListAliasesStack = []; + + delete parser.yy.caseDetermined; + delete parser.yy.cursorFound; + delete parser.yy.partialCursor; + + // Fix for parser bug when switching lexer states + if (!lexerModified) { + const originalSetInput = parser.lexer.setInput; + parser.lexer.setInput = function (input, yy) { + return originalSetInput.bind(parser.lexer)(input, yy); + }; + lexerModified = true; + } + + parser.prepareNewStatement(); + + const REASONABLE_SURROUNDING_LENGTH = 150000; // About 3000 lines before and after + + if (beforeCursor.length > REASONABLE_SURROUNDING_LENGTH) { + if (beforeCursor.length - beforeCursor.lastIndexOf(';') > REASONABLE_SURROUNDING_LENGTH) { + // Bail out if the last complete statement is more than 150000 chars before + return {}; + } + // Cut it at the first statement found within 150000 chars before + const lastReasonableChunk = beforeCursor.substring( + beforeCursor.length - REASONABLE_SURROUNDING_LENGTH + ); + beforeCursor = lastReasonableChunk.substring(lastReasonableChunk.indexOf(';') + 1); + } + + if (afterCursor.length > REASONABLE_SURROUNDING_LENGTH) { + if (afterCursor.length - afterCursor.indexOf(';') > REASONABLE_SURROUNDING_LENGTH) { + // No need to bail out for what's comes after, we can still get keyword completion + afterCursor = ''; + } else { + // Cut it at the last statement found within 150000 chars after + const firstReasonableChunk = afterCursor.substring(0, REASONABLE_SURROUNDING_LENGTH); + afterCursor = firstReasonableChunk.substring(0, firstReasonableChunk.lastIndexOf(';')); + } + } + + parser.yy.partialLengths = parser.identifyPartials(beforeCursor, afterCursor); + + if (parser.yy.partialLengths.left > 0) { + beforeCursor = beforeCursor.substring(0, beforeCursor.length - parser.yy.partialLengths.left); + } + + if (parser.yy.partialLengths.right > 0) { + afterCursor = afterCursor.substring(parser.yy.partialLengths.right); + } + + let result; + try { + // Add |CURSOR| or |PARTIAL_CURSOR| to represent the different cursor states in the lexer + result = parser.parse( + beforeCursor + + (beforeCursor.length === 0 || /[\s(]$/.test(beforeCursor) ? ' \u2020 ' : '\u2021') + + afterCursor + ); + } catch (err) { + // On any error try to at least return any existing result + if (typeof parser.yy.result === 'undefined') { + throw err; + } + if (debug) { + console.warn(err); + console.warn(err.stack); + } + result = parser.yy.result; + } + if (parser.yy.errors.length > 0) { + parser.yy.result.errors = parser.yy.errors; + if (debug) { + console.warn(parser.yy.errors); + } + } + try { + linkTablePrimaries(); + parser.commitLocations(); + // Clean up and prioritize + adjustForPartialBackticks(parser); + prioritizeSuggestions(); + } catch (err) { + if (debug) { + console.warn(err); + console.warn(err.stack); + } + } + + parser.yy.allLocations.sort((a, b) => { + if (a.location.first_line !== b.location.first_line) { + return a.location.first_line - b.location.first_line; + } + if (a.location.first_column !== b.location.first_column) { + return a.location.first_column - b.location.first_column; + } + if (a.location.last_column !== b.location.last_column) { + return b.location.last_column - a.location.last_column; + } + return b.type.localeCompare(a.type); + }); + parser.yy.result.locations = parser.yy.allLocations; + parser.yy.result.definitions = parser.yy.definitions; + + parser.yy.result.locations.forEach(location => { + delete location.linked; + }); + if (typeof parser.yy.result.suggestColumns !== 'undefined') { + delete parser.yy.result.suggestColumns.linked; + } + + SIMPLE_TABLE_REF_SUGGESTIONS.forEach(suggestionType => { + if (typeof parser.yy.result[suggestionType] !== 'undefined') { + delete parser.yy.result[suggestionType].linked; + } + }); + + if (typeof parser.yy.result.colRef !== 'undefined') { + delete parser.yy.result.colRef.linked; + } + if (typeof parser.yy.result.suggestKeyValues !== 'undefined') { + delete parser.yy.result.suggestKeyValues.linked; + } + + if (typeof result.error !== 'undefined' && typeof result.error.expected !== 'undefined') { + // Remove the cursor from expected tokens + result.error.expected = result.error.expected.filter(token => token.indexOf('CURSOR') === -1); + } + + if (typeof result.error !== 'undefined' && result.error.recoverable) { + delete result.error; + } + + // Adjust all the statement locations to include white space surrounding them + let lastStatementLocation = null; + result.locations.forEach(location => { + if (location.type === 'statement') { + if (lastStatementLocation === null) { + location.location.first_line = 1; + location.location.first_column = 1; + } else { + location.location.first_line = lastStatementLocation.location.last_line; + location.location.first_column = lastStatementLocation.location.last_column + 1; + } + lastStatementLocation = location; + } + }); + + return result; + }; +}; + +export default { + initSqlParser: initSqlParser, + initSyntaxParser: initSyntaxParser +}; diff --git a/desktop/core/src/desktop/js/parse/sql/sqlParserRepository.ts b/desktop/core/src/desktop/js/parse/sql/sqlParserRepository.ts index 88251487a29..5fc1203abd5 100644 --- a/desktop/core/src/desktop/js/parse/sql/sqlParserRepository.ts +++ b/desktop/core/src/desktop/js/parse/sql/sqlParserRepository.ts @@ -29,7 +29,9 @@ const AUTOCOMPLETE_MODULES = { ksql: () => import(/* webpackChunkName: "ksql-parser" */ './ksql/ksqlAutocompleteParser'), phoenix: () => import(/* webpackChunkName: "phoenix-parser" */ './phoenix/phoenixAutocompleteParser'), - presto: () => import(/* webpackChunkName: "presto-parser" */ './presto/prestoAutocompleteParser') + presto: () => import(/* webpackChunkName: "presto-parser" */ './presto/prestoAutocompleteParser'), + sparksql: () => + import(/* webpackChunkName: "sparksql-parser" */ './sparksql/sparksqlAutocompleteParser') }; const SYNTAX_MODULES = { calcite: () => import(/* webpackChunkName: "calcite-parser" */ './calcite/calciteSyntaxParser'), @@ -40,7 +42,9 @@ const SYNTAX_MODULES = { impala: () => import(/* webpackChunkName: "impala-parser" */ './impala/impalaSyntaxParser'), ksql: () => import(/* webpackChunkName: "ksql-parser" */ './ksql/ksqlSyntaxParser'), phoenix: () => import(/* webpackChunkName: "phoenix-parser" */ './phoenix/phoenixSyntaxParser'), - presto: () => import(/* webpackChunkName: "presto-parser" */ './presto/prestoSyntaxParser') + presto: () => import(/* webpackChunkName: "presto-parser" */ './presto/prestoSyntaxParser'), + sparksql: () => + import(/* webpackChunkName: "sparksql-parser" */ './sparksql/sparksqlSyntaxParser') }; export class SqlParserRepository implements SqlParserProvider {