diff --git a/packages/mysql-on-sqlite/src/mysql/native/class-wp-mysql-native-parser-node.php b/packages/mysql-on-sqlite/src/mysql/native/class-wp-mysql-native-parser-node.php index 25d839c50..1484e49a6 100644 --- a/packages/mysql-on-sqlite/src/mysql/native/class-wp-mysql-native-parser-node.php +++ b/packages/mysql-on-sqlite/src/mysql/native/class-wp-mysql-native-parser-node.php @@ -140,6 +140,82 @@ public function get_descendant_tokens( ?int $token_id = null ): array { return wp_sqlite_mysql_native_ast_get_descendant_tokens( $this, $token_id ); } + public function get_native_handle(): int { + return wp_sqlite_mysql_native_ast_get_native_handle( $this ); + } + + public function get_native_child_handles( ?int $handle = null ): array { + return wp_sqlite_mysql_native_ast_get_native_child_handles( + $this, + $handle ?? $this->get_native_handle() + ); + } + + public function get_native_descendant_handles( ?int $handle = null ): array { + return wp_sqlite_mysql_native_ast_get_native_descendant_handles( + $this, + $handle ?? $this->get_native_handle() + ); + } + + /** + * Return descendant metadata without materializing PHP node/token objects. + * + * The result is a flat list of `[kind, id, kind, id, ...]` pairs, where + * kind `0` is a parser node and kind `1` is a token. The id is the node's + * rule id or the token id. + * + * @param int|null $handle Optional native node handle. Defaults to this node. + * @return int[] + */ + public function get_native_descendant_id_rows( ?int $handle = null ): array { + return wp_sqlite_mysql_native_ast_get_native_descendant_id_rows( + $this, + $handle ?? $this->get_native_handle() + ); + } + + public function get_native_descendant_packed_id_rows( ?int $handle = null ): array { + return wp_sqlite_mysql_native_ast_get_native_descendant_packed_id_rows( + $this, + $handle ?? $this->get_native_handle() + ); + } + + /** + * Return descendant metadata without materializing PHP node/token objects. + * + * The result is a flat list of `[kind, id, start, length, ...]` rows. + * Kind `0` is a parser node and kind `1` is a token. Token rows carry the + * token byte span. Node rows use `start = -1` and `length = 0` because the + * pure-PHP parser nodes do not store spans, and the benchmark uses this API + * for direct PHP/native comparisons. + * + * @param int|null $handle Optional native node handle. Defaults to this node. + * @return int[] + */ + public function get_native_descendant_scalar_rows( ?int $handle = null ): array { + return wp_sqlite_mysql_native_ast_get_native_descendant_scalar_rows( + $this, + $handle ?? $this->get_native_handle() + ); + } + + public function get_native_descendant_packed_scalar_rows( ?int $handle = null ): array { + return wp_sqlite_mysql_native_ast_get_native_descendant_packed_scalar_rows( + $this, + $handle ?? $this->get_native_handle() + ); + } + + public function get_native_handle_kind( int $handle ): int { + return wp_sqlite_mysql_native_ast_get_native_handle_kind( $this, $handle ); + } + + public function get_native_handle_id( int $handle ): int { + return wp_sqlite_mysql_native_ast_get_native_handle_id( $this, $handle ); + } + /** @inheritDoc */ public function get_start(): int { if ( $this->was_mutated() ) { diff --git a/packages/mysql-on-sqlite/src/mysql/native/trait-wp-mysql-native-parser-impl.php b/packages/mysql-on-sqlite/src/mysql/native/trait-wp-mysql-native-parser-impl.php index c53e96e53..1fa0e8d4b 100644 --- a/packages/mysql-on-sqlite/src/mysql/native/trait-wp-mysql-native-parser-impl.php +++ b/packages/mysql-on-sqlite/src/mysql/native/trait-wp-mysql-native-parser-impl.php @@ -52,4 +52,44 @@ public function get_query_ast(): ?WP_Parser_Node { public function parse() { return $this->native->parse(); } + + public function parse_native_descendant_id_rows(): ?array { + return $this->native->parse_native_descendant_id_rows(); + } + + public function parse_native_descendant_packed_id_rows(): ?array { + return $this->native->parse_native_descendant_packed_id_rows(); + } + + public function parse_native_descendant_scalar_rows(): ?array { + return $this->native->parse_native_descendant_scalar_rows(); + } + + public function parse_native_descendant_packed_scalar_rows(): ?array { + return $this->native->parse_native_descendant_packed_scalar_rows(); + } + + public function parse_native_descendant_packed_id_stats(): ?array { + return $this->native->parse_native_descendant_packed_id_stats(); + } + + public function parse_native_descendant_packed_scalar_stats( bool $consume_token_bytes = false ): ?array { + return $this->native->parse_native_descendant_packed_scalar_stats( $consume_token_bytes ); + } + + public function parse_sql_native_descendant_packed_id_stats( string $sql ): ?array { + return $this->native->parse_sql_native_descendant_packed_id_stats( $sql ); + } + + public function parse_sql_native_descendant_packed_scalar_stats( string $sql, bool $consume_token_bytes = false ): ?array { + return $this->native->parse_sql_native_descendant_packed_scalar_stats( $sql, $consume_token_bytes ); + } + + public function parse_sql_batch_native_descendant_packed_id_stats( array $queries ): array { + return $this->native->parse_sql_batch_native_descendant_packed_id_stats( $queries ); + } + + public function parse_sql_batch_native_descendant_packed_scalar_stats( array $queries, bool $consume_token_bytes = false ): array { + return $this->native->parse_sql_batch_native_descendant_packed_scalar_stats( $queries, $consume_token_bytes ); + } } diff --git a/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-mysql-on-sqlite.php b/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-mysql-on-sqlite.php index 7130fb631..d7f1edfb9 100644 --- a/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-mysql-on-sqlite.php +++ b/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-mysql-on-sqlite.php @@ -443,6 +443,13 @@ class WP_PDO_MySQL_On_SQLite extends PDO { */ private $connection; + /** + * Native SQLite connection used for direct hot-path execution. + * + * @var object|null + */ + private $native_sqlite_connection; + /** * User-defined functions registered on the SQLite connection. * @@ -472,9 +479,9 @@ class WP_PDO_MySQL_On_SQLite extends PDO { private $last_sqlite_queries = array(); /** - * A PDO SQLite statement that represents the result of the last emulated query. + * A statement that represents the result of the last emulated query. * - * @var PDOStatement|null + * @var object|null */ private $last_result_statement; @@ -872,6 +879,15 @@ public function query( string $query, ?int $fetch_mode = null, ...$fetch_mode_ar $this->last_mysql_query = $query; try { + if ( + $this->execute_native_sqlite_plan( $query, $fetch_mode, $fetch_mode_args ) + || ( ! $this->has_native_sqlite_plan_translator() && $this->execute_fast_query( $query ) ) + ) { + $stmt = new WP_PDO_Proxy_Statement( $this->last_result_statement, $this->last_affected_rows ); + $stmt->setFetchMode( $fetch_mode, ...$fetch_mode_args ); + return $stmt; + } + // Parse the MySQL query. $parser = $this->create_parser( $query ); $parser->next_query(); @@ -883,7 +899,6 @@ public function query( string $query, ?int $fetch_mode = null, ...$fetch_mode_ar if ( $parser->next_query() ) { throw $this->new_driver_exception( 'Multi-query is not supported.' ); } - /* * Determine if we need to wrap the translated queries in a transaction. * @@ -1376,6 +1391,470 @@ public function execute_sqlite_query( string $sql, array $params = array() ): PD return $this->connection->query( $sql, $params ); } + /** + * Execute a compact SQLite plan returned by the native Rust extension. + * + * @param string $query Full SQL statement string. + * @param int $fetch_mode PDO fetch mode. + * @param array $fetch_mode_args Additional fetch mode arguments. + * @return bool Whether the query was handled. + */ + private function execute_native_sqlite_plan( string $query, int $fetch_mode, array $fetch_mode_args ): bool { + if ( ! $this->has_native_sqlite_plan_translator() ) { + return false; + } + + $can_execute_directly = $this->can_execute_native_sqlite_directly( $fetch_mode, $fetch_mode_args ); + $plan_code = WP_MySQL_Native_Lexer::translate_sqlite_plan_code( $query ); + if ( + $can_execute_directly + && ( + 2 === $plan_code + || ( 0 === $plan_code && false !== stripos( $query, 'sql_calc_found_rows' ) ) + ) + ) { + $stmt = $this->execute_native_mysql_plan( $query ); + if ( $stmt ) { + $this->last_result_statement = $stmt; + $this->last_affected_rows = $stmt->rowCount(); + $native_found_rows = method_exists( $stmt, 'foundRows' ) ? $stmt->foundRows() : -1; + if ( $native_found_rows >= 0 ) { + $this->found_rows = $native_found_rows; + $this->is_readonly = true; + $this->store_last_column_meta_from_statement( $stmt ); + } + return true; + } + } + + switch ( $plan_code ) { + case 1: + $this->found_rows = $query; + $stmt = $this->execute_sqlite_query( $query ); + $this->is_readonly = true; + $this->last_result_statement = $stmt; + $this->store_last_column_meta_from_statement( $stmt ); + return true; + + case 2: + $stmt = $this->execute_sqlite_query( $query ); + $this->last_result_statement = $stmt; + $this->last_affected_rows = $stmt->rowCount(); + return true; + + case 3: + $count = $this->get_found_rows_count(); + $sqlite_query = sprintf( + 'SELECT %d AS %s', + $count, + $this->quote_sqlite_identifier( 'FOUND_ROWS()' ) + ); + $this->is_readonly = true; + $this->last_result_statement = $this->execute_sqlite_query( $sqlite_query ); + $this->store_last_column_meta_from_statement( $this->last_result_statement ); + return true; + } + + $plan = WP_MySQL_Native_Lexer::translate_sqlite_plan( $query ); + if ( ! is_array( $plan ) || ! isset( $plan[0] ) ) { + return false; + } + + switch ( $plan[0] ) { + case 'set_session_sql_mode': + $modes = '' === $plan[1] ? array() : explode( ',', $plan[1] ); + $this->active_sql_modes = array_map( 'strtoupper', $modes ); + $this->last_result_statement = $this->create_result_statement_from_data( array(), array() ); + $this->last_affected_rows = 0; + return true; + + case 'select_session_sql_mode': + $value = implode( ',', $this->active_sql_modes ); + $sqlite_query = sprintf( + 'SELECT %s AS %s', + $this->connection->get_pdo()->quote( $value ), + $this->quote_sqlite_identifier( $plan[1] ) + ); + $this->is_readonly = true; + $this->last_result_statement = $this->execute_sqlite_query( $sqlite_query ); + $this->store_last_column_meta_from_statement( $this->last_result_statement ); + return true; + + case 'select_found_rows': + $count = $this->get_found_rows_count(); + $sqlite_query = sprintf( + 'SELECT %d AS %s', + $count, + $this->quote_sqlite_identifier( 'FOUND_ROWS()' ) + ); + $this->is_readonly = true; + $this->last_result_statement = $this->execute_sqlite_query( $sqlite_query ); + $this->store_last_column_meta_from_statement( $this->last_result_statement ); + return true; + + case 'select_passthrough': + $sqlite_query = $plan[1]; + if ( isset( $plan[2] ) && '' !== $plan[2] ) { + $this->found_rows = (int) $this->execute_sqlite_query( + sprintf( 'SELECT COUNT(*) AS cnt FROM (%s)', $plan[2] ) + )->fetchColumn(); + } else { + $this->found_rows = $sqlite_query; + } + + $stmt = $this->execute_sqlite_query( $sqlite_query ); + $this->is_readonly = true; + $this->last_result_statement = $stmt; + $this->store_last_column_meta_from_statement( $stmt ); + return true; + + case 'update_passthrough': + $stmt = $this->execute_sqlite_query( $plan[1] ); + $this->last_result_statement = $stmt; + $this->last_affected_rows = $stmt->rowCount(); + return true; + } + + return false; + } + + /** + * Translate and execute a hot-path MySQL query entirely in the native Rust SQLite path. + * + * @param string $query MySQL query. + * @return object|null Native statement, or null when native execution is unavailable. + */ + private function execute_native_mysql_plan( string $query ): ?object { + $connection = $this->get_native_sqlite_connection(); + if ( ! $connection || ! method_exists( $connection, 'queryMysql' ) ) { + return null; + } + + try { + $stmt = $connection->queryMysql( $query ); + } catch ( Throwable $e ) { + return null; + } + if ( ! $stmt ) { + return null; + } + + if ( method_exists( $stmt, 'sqliteQueries' ) ) { + foreach ( $stmt->sqliteQueries() as $sql ) { + $this->last_sqlite_queries[] = array( + 'sql' => $sql, + 'params' => array(), + ); + } + } + + return $stmt; + } + + /** + * Get a native Rust SQLite connection for direct execution. + * + * @return object|null Native connection, or null when unsafe/unavailable. + */ + private function get_native_sqlite_connection(): ?object { + if ( + $this->in_transaction + || ! class_exists( 'WP_SQLite_Native_Connection', false ) + ) { + return null; + } + + $path = $this->connection->get_path(); + if ( ! is_string( $path ) || ':memory:' === $path ) { + return null; + } + + if ( null === $this->native_sqlite_connection ) { + $this->native_sqlite_connection = new WP_SQLite_Native_Connection( $path ); + } + + return $this->native_sqlite_connection; + } + + /** + * Check whether direct native execution can preserve the requested fetch mode. + * + * @param int $fetch_mode PDO fetch mode. + * @param array $fetch_mode_args Additional fetch mode arguments. + * @return bool Whether direct native execution can be used. + */ + private function can_execute_native_sqlite_directly( int $fetch_mode, array $fetch_mode_args ): bool { + if ( count( $fetch_mode_args ) > 0 ) { + return false; + } + + return in_array( + $fetch_mode, + array( + PDO::FETCH_DEFAULT, + PDO::FETCH_ASSOC, + PDO::FETCH_NUM, + PDO::FETCH_BOTH, + PDO::FETCH_OBJ, + PDO::FETCH_COLUMN, + PDO::FETCH_NAMED, + ), + true + ); + } + + /** + * Check whether the loaded native extension can translate common SQL shapes. + * + * @return bool Whether the native SQLite plan translator is available. + */ + private function has_native_sqlite_plan_translator(): bool { + static $available = null; + + if ( null === $available ) { + $available = + class_exists( 'WP_MySQL_Native_Lexer', false ) + && method_exists( 'WP_MySQL_Native_Lexer', 'translate_sqlite_plan' ) + && method_exists( 'WP_MySQL_Native_Lexer', 'translate_sqlite_plan_code' ); + } + + return $available; + } + + /** + * Execute common WordPress queries directly in SQLite. + * + * Most frontend requests issue many read-only queries that are already valid + * SQLite. Avoiding the MySQL parser/translator for those queries improves the + * pure-PHP path. When the native extension is loaded, the equivalent shortcut + * is handled by execute_native_sqlite_plan(). + * + * @param string $query Full SQL statement string. + * @return bool Whether the query was handled. + */ + private function execute_fast_query( string $query ): bool { + $sql = trim( $query ); + $sql = rtrim( $sql, " \t\r\n;" ); + + if ( preg_match( '/^SET\s+SESSION\s+sql_mode\s*=\s*([\'"])(.*?)\1\s*$/i', $sql, $matches ) ) { + $modes = '' === $matches[2] ? array() : explode( ',', $matches[2] ); + $this->active_sql_modes = array_map( 'strtoupper', $modes ); + $this->last_result_statement = $this->create_result_statement_from_data( array(), array() ); + $this->last_affected_rows = 0; + return true; + } + + if ( $this->is_fast_update_passthrough_candidate( $sql ) ) { + $stmt = $this->execute_sqlite_query( $sql ); + $this->last_result_statement = $stmt; + $this->last_affected_rows = $stmt->rowCount(); + return true; + } + + if ( preg_match( '/^SELECT\s+(@@SESSION\.sql_mode)\s*$/i', $sql, $matches ) ) { + $value = implode( ',', $this->active_sql_modes ); + $sqlite_query = sprintf( + 'SELECT %s AS %s', + $this->connection->get_pdo()->quote( $value ), + $this->quote_sqlite_identifier( $matches[1] ) + ); + $this->is_readonly = true; + $this->last_result_statement = $this->execute_sqlite_query( $sqlite_query ); + $this->store_last_column_meta_from_statement( $this->last_result_statement ); + return true; + } + + if ( preg_match( '/^SELECT\s+FOUND_ROWS\s*\(\s*\)\s*$/i', $sql ) ) { + $count = $this->get_found_rows_count(); + $sqlite_query = sprintf( + 'SELECT %d AS %s', + $count, + $this->quote_sqlite_identifier( 'FOUND_ROWS()' ) + ); + $this->is_readonly = true; + $this->last_result_statement = $this->execute_sqlite_query( $sqlite_query ); + $this->store_last_column_meta_from_statement( $this->last_result_statement ); + return true; + } + + if ( ! $this->is_fast_select_passthrough_candidate( $sql ) ) { + return false; + } + + $has_sql_calc_found_rows = preg_match( '/^SELECT\s+SQL_CALC_FOUND_ROWS\s+/i', $sql ); + $sqlite_query = $has_sql_calc_found_rows + ? preg_replace( '/^SELECT\s+SQL_CALC_FOUND_ROWS\s+/i', 'SELECT ', $sql ) + : $sql; + + if ( $has_sql_calc_found_rows ) { + $count_query = preg_replace( + '/\s+LIMIT\s+\d+\s*(?:,\s*\d+|OFFSET\s+\d+)?\s*$/i', + '', + $sqlite_query + ); + $this->found_rows = (int) $this->execute_sqlite_query( + sprintf( 'SELECT COUNT(*) AS cnt FROM (%s)', $count_query ) + )->fetchColumn(); + } else { + $this->found_rows = $sqlite_query; + } + + $stmt = $this->execute_sqlite_query( $sqlite_query ); + $this->store_last_column_meta_from_statement( $stmt ); + + $this->is_readonly = true; + $this->last_result_statement = $stmt; + return true; + } + + /** + * Get the value for a "FOUND_ROWS()" emulation query. + * + * @return int Found rows count. + */ + private function get_found_rows_count(): int { + $found_rows = $this->found_rows; + if ( is_int( $found_rows ) ) { + return $found_rows; + } elseif ( is_string( $found_rows ) ) { + return (int) $this->execute_sqlite_query( + sprintf( 'SELECT COUNT(*) FROM (%s)', $found_rows ) + )->fetchColumn(); + } elseif ( is_array( $found_rows ) && isset( $found_rows[0] ) ) { + return (int) $this->execute_sqlite_query( + sprintf( 'SELECT COUNT(*) FROM (%s)', $found_rows[0] ), + $found_rows[1] ?? array() + )->fetchColumn(); + } + + return 0; + } + + /** + * Check if a SELECT can bypass the MySQL parser/translator. + * + * @param string $sql SQL statement without trailing semicolon. + * @return bool Whether the query can be passed through to SQLite. + */ + private function is_fast_select_passthrough_candidate( string $sql ): bool { + if ( ! preg_match( '/^SELECT\s+/i', $sql ) ) { + return false; + } + + if ( ! preg_match( '/\bFROM\b/i', $sql ) ) { + return false; + } + + if ( preg_match( '/\binformation_schema\b|_wp_sqlite_/i', $sql ) ) { + return false; + } + + if ( ! preg_match( '/\b(?:FROM|JOIN)\s+(?:`?[a-z0-9_]+`?\.)?' . $this->get_fast_query_table_pattern() . '\b/i', $sql ) ) { + return false; + } + + if ( + strpos( $sql, ';' ) !== false + || strpos( $sql, '\\' ) !== false + || strpos( $sql, '@' ) !== false + || strpos( $sql, '--' ) !== false + || strpos( $sql, '/*' ) !== false + || strpos( $sql, '#' ) !== false + || strpos( $sql, '->' ) !== false + || preg_match( '/\b0x[0-9a-f]/i', $sql ) + || preg_match( '/\b_[a-z0-9]+\s*\'/i', $sql ) + ) { + return false; + } + + if ( + preg_match( + '/\b(?:UNION|INTERSECT|EXCEPT|MATCH|AGAINST|COLLATE|INTERVAL|RLIKE|BINARY|FOR\s+UPDATE|LOCK\s+IN\s+SHARE\s+MODE|USE\s+(?:INDEX|KEY)|FORCE\s+(?:INDEX|KEY)|IGNORE\s+(?:INDEX|KEY))\b/i', + $sql + ) + ) { + return false; + } + + if ( + preg_match( + '/\b(?:IF|CONCAT|CHAR_LENGTH|DATE_ADD|DATE_SUB|DATE_FORMAT|STR_TO_DATE|RAND|REGEXP|FOUND_ROWS|DATABASE|VERSION|LAST_INSERT_ID|ROW_COUNT|GROUP_CONCAT)\s*\(/i', + $sql + ) + ) { + return false; + } + + if ( preg_match( '/\bCAST\s*\([^)]*\s+AS\s+(?:UNSIGNED|SIGNED)\b/i', $sql ) ) { + return false; + } + + if ( preg_match( '/\bSQL_CALC_FOUND_ROWS\b/i', $sql ) && ! preg_match( '/^SELECT\s+SQL_CALC_FOUND_ROWS\s+/i', $sql ) ) { + return false; + } + + return true; + } + + /** + * Check if an UPDATE can bypass the MySQL parser/translator. + * + * @param string $sql SQL statement without trailing semicolon. + * @return bool Whether the query can be passed through to SQLite. + */ + private function is_fast_update_passthrough_candidate( string $sql ): bool { + if ( ! preg_match( '/^UPDATE\s+(?:`?[a-z0-9_]+`?\.)?' . $this->get_fast_query_table_pattern() . '\s+SET\s+/i', $sql ) ) { + return false; + } + + if ( + strpos( $sql, ';' ) !== false + || strpos( $sql, '\\' ) !== false + || strpos( $sql, '@' ) !== false + || strpos( $sql, '--' ) !== false + || strpos( $sql, '/*' ) !== false + || strpos( $sql, '#' ) !== false + || strpos( $sql, '->' ) !== false + || preg_match( '/\b0x[0-9a-f]/i', $sql ) + || preg_match( '/\b_[a-z0-9]+\s*\'/i', $sql ) + ) { + return false; + } + + if ( + preg_match( + '/\b(?:LOW_PRIORITY|IGNORE|JOIN|ORDER\s+BY|LIMIT|MATCH|AGAINST|COLLATE|INTERVAL|RLIKE|BINARY)\b/i', + $sql + ) + ) { + return false; + } + + if ( + preg_match( + '/\b(?:IF|CONCAT|CHAR_LENGTH|DATE_ADD|DATE_SUB|DATE_FORMAT|STR_TO_DATE|RAND|REGEXP|FOUND_ROWS|DATABASE|VERSION|LAST_INSERT_ID|ROW_COUNT|GROUP_CONCAT)\s*\(/i', + $sql + ) + ) { + return false; + } + + if ( preg_match( '/\bCAST\s*\([^)]*\s+AS\s+(?:UNSIGNED|SIGNED)\b/i', $sql ) ) { + return false; + } + + return true; + } + + /** + * Table names that are safe to pass through when the SQL itself is SQLite-compatible. + * + * @return string Regular-expression fragment. + */ + private function get_fast_query_table_pattern(): string { + return '`?(?:[a-z0-9]+_)*(?:actionscheduler_actions|actionscheduler_claims|actionscheduler_groups|actionscheduler_logs|blogmeta|blogs|commentmeta|comments|links|options|postmeta|posts|registration_log|signups|site|sitemeta|term_relationships|term_taxonomy|termmeta|terms|usermeta|users|wc_admin_note_actions|wc_admin_notes|wc_category_lookup|wc_customer_lookup|wc_download_log|wc_order_addresses|wc_order_coupon_lookup|wc_order_operational_data|wc_order_product_lookup|wc_order_stats|wc_order_tax_lookup|wc_orders|wc_orders_meta|wc_product_attributes_lookup|wc_product_download_directories|wc_product_meta_lookup|wc_rate_limits|wc_reserved_stock|wc_tax_rate_classes|wc_webhooks|woocommerce_api_keys|woocommerce_attribute_taxonomies|woocommerce_downloadable_product_permissions|woocommerce_log|woocommerce_order_itemmeta|woocommerce_order_items|woocommerce_payment_tokenmeta|woocommerce_payment_tokens|woocommerce_sessions|woocommerce_shipping_zone_locations|woocommerce_shipping_zone_methods|woocommerce_shipping_zones|woocommerce_tax_rate_locations|woocommerce_tax_rates)`?'; + } + /** * Translate and execute a MySQL query in SQLite. * @@ -5641,9 +6120,9 @@ private function translate_update_list( string $table_name, WP_Parser_Node $pare * This function stores the original SQLite column metadata as-is, without * converting it into MySQL column metadata. That is done only when needed. * - * @param PDOStatement $stmt The PDOStatement object containing the SQLite column metadata. + * @param object $stmt The statement object containing the SQLite column metadata. */ - private function store_last_column_meta_from_statement( PDOStatement $stmt ): void { + private function store_last_column_meta_from_statement( object $stmt ): void { $this->last_column_meta = array(); for ( $i = 0; $i < $stmt->columnCount(); $i++ ) { /* diff --git a/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-proxy-statement.php b/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-proxy-statement.php index f56340d70..0071ddd02 100644 --- a/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-proxy-statement.php +++ b/packages/mysql-on-sqlite/src/sqlite/class-wp-pdo-proxy-statement.php @@ -114,7 +114,7 @@ class WP_PDO_Proxy_Statement extends PDOStatement { /** * The original PDO statement. * - * @var PDOStatement + * @var object */ private $statement; @@ -128,11 +128,11 @@ class WP_PDO_Proxy_Statement extends PDOStatement { /** * Constructor. * - * @param PDOStatement $statement The original PDO statement. - * @param int $affected_rows The number of affected rows. + * @param object $statement The original statement. + * @param int $affected_rows The number of affected rows. */ public function __construct( - PDOStatement $statement, + object $statement, ?int $affected_rows = null ) { $this->statement = $statement; diff --git a/packages/mysql-on-sqlite/src/sqlite/class-wp-sqlite-connection.php b/packages/mysql-on-sqlite/src/sqlite/class-wp-sqlite-connection.php index 1509a1e64..7cdba754d 100644 --- a/packages/mysql-on-sqlite/src/sqlite/class-wp-sqlite-connection.php +++ b/packages/mysql-on-sqlite/src/sqlite/class-wp-sqlite-connection.php @@ -40,6 +40,13 @@ class WP_SQLite_Connection { */ private $pdo; + /** + * SQLite database path, when known. + * + * @var string|null + */ + private $path; + /** * A query logger callback. * @@ -70,14 +77,15 @@ class WP_SQLite_Connection { */ public function __construct( array $options ) { // Setup PDO connection. + $this->path = isset( $options['path'] ) && is_string( $options['path'] ) ? $options['path'] : null; if ( isset( $options['pdo'] ) && $options['pdo'] instanceof PDO ) { $this->pdo = $options['pdo']; } else { - if ( ! isset( $options['path'] ) || ! is_string( $options['path'] ) ) { + if ( null === $this->path ) { throw new InvalidArgumentException( 'Option "path" is required when "connection" is not provided.' ); } $pdo_class = PHP_VERSION_ID >= 80400 ? PDO\SQLite::class : PDO::class; - $this->pdo = new $pdo_class( 'sqlite:' . $options['path'] ); + $this->pdo = new $pdo_class( 'sqlite:' . $this->path ); } // Throw exceptions on error. @@ -199,6 +207,15 @@ public function get_pdo(): PDO { return $this->pdo; } + /** + * Get the SQLite database path, when known. + * + * @return string|null SQLite database path. + */ + public function get_path(): ?string { + return $this->path; + } + /** * Set a logger for the queries. * diff --git a/packages/mysql-on-sqlite/tests/WP_PDO_MySQL_On_SQLite_PDO_API_Tests.php b/packages/mysql-on-sqlite/tests/WP_PDO_MySQL_On_SQLite_PDO_API_Tests.php index 9ac8a3014..d6b0a0572 100644 --- a/packages/mysql-on-sqlite/tests/WP_PDO_MySQL_On_SQLite_PDO_API_Tests.php +++ b/packages/mysql-on-sqlite/tests/WP_PDO_MySQL_On_SQLite_PDO_API_Tests.php @@ -93,6 +93,45 @@ public function test_query(): void { } } + public function test_query_preserves_session_sql_mode_case(): void { + $this->driver->query( "SET SESSION sql_mode = 'no_zero_date,strict_trans_tables'" ); + + $result = $this->driver->query( 'SELECT @@session.SQL_mode', PDO::FETCH_ASSOC ); + + $this->assertSame( + array( + '@@session.SQL_mode' => 'NO_ZERO_DATE,STRICT_TRANS_TABLES', + ), + $result->fetch() + ); + } + + public function test_query_emulates_found_rows_for_simple_selects(): void { + $this->driver->query( 'CREATE TABLE wp_posts (ID INTEGER PRIMARY KEY, post_status TEXT)' ); + $this->driver->query( "INSERT INTO wp_posts (ID, post_status) VALUES (1, 'publish'), (2, 'draft'), (3, 'publish'), (4, 'publish')" ); + + $posts = $this->driver->query( + "SELECT SQL_CALC_FOUND_ROWS ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID ASC LIMIT 0, 2", + PDO::FETCH_ASSOC + ); + $this->assertSame( + array( + array( 'ID' => '1' ), + array( 'ID' => '3' ), + ), + $posts->fetchAll() + ); + + $found_rows = $this->driver->query( 'SELECT FOUND_ROWS()', PDO::FETCH_ASSOC ); + + $this->assertSame( + array( + 'FOUND_ROWS()' => '3', + ), + $found_rows->fetch() + ); + } + /** * @dataProvider data_pdo_fetch_methods */ diff --git a/packages/mysql-on-sqlite/tests/mysql/WP_MySQL_Server_Suite_Parser_Tests.php b/packages/mysql-on-sqlite/tests/mysql/WP_MySQL_Server_Suite_Parser_Tests.php index 027698849..6c58facf2 100644 --- a/packages/mysql-on-sqlite/tests/mysql/WP_MySQL_Server_Suite_Parser_Tests.php +++ b/packages/mysql-on-sqlite/tests/mysql/WP_MySQL_Server_Suite_Parser_Tests.php @@ -10,28 +10,21 @@ class WP_MySQL_Server_Suite_Parser_Tests extends TestCase { const GRAMMAR_PATH = __DIR__ . '/../../src/mysql/mysql-grammar.php'; /** - * Some of the queries in the test suite are known to fail parsing. - * We'll skip them in the tests now, gradually fixing these cases. + * @var WP_Parser_Grammar */ - const KNOWN_FAILURES = array( - 'SELECT 1 /*!99999 /* */ */' => true, - 'select 1ea10.1a20,1e+ 1e+10 from 1ea10' => true, - "聠聡聢聣聤聬聭聮聯聰聲聽隆垄拢陇楼卤潞禄录陆戮 聶職聳聴\n0聲5\n1聲5\n2聲5\n3聲5\n4\n\nSET NAMES gb18030" => true, - "alter user mysqltest_7@ identified by 'systpass'" => true, - "SELECT 'a%' LIKE 'a!%' ESCAPE '!', 'a%' LIKE 'a!' || '%' ESCAPE '!'" => true, - "SELECT 'a%' NOT LIKE 'a!%' ESCAPE '!', 'a%' NOT LIKE 'a!' || '%' ESCAPE '!'" => true, - "SELECT 'a%' LIKE 'a!%' ESCAPE '$', 'a%' LIKE 'a!' || '%' ESCAPE '$'" => true, - "SELECT 'a%' NOT LIKE 'a!%' ESCAPE '$', 'a%' NOT LIKE 'a!' || '%' ESCAPE '$'" => true, - 'ALTER SCHEMA s1 READ ONLY DEFAULT' => true, - ); + private static $grammar; /** - * @var WP_Parser_Grammar + * Some of the queries in the test suite are known to fail parsing. + * We'll skip them in the tests now, gradually fixing these cases. + * + * @var array */ - private static $grammar; + private static $known_failures; public static function setUpBeforeClass(): void { - self::$grammar = new WP_Parser_Grammar( include self::GRAMMAR_PATH ); + self::$grammar = new WP_Parser_Grammar( include self::GRAMMAR_PATH ); + self::$known_failures = include __DIR__ . '/data/mysql-server-tests-known-parser-failures.php'; } /** @@ -54,7 +47,7 @@ public function test_parse_mysql_test_suite( array $batch ): void { $parser = new WP_MySQL_Parser( self::$grammar, $tokens ); $ast = $parser->parse(); - if ( self::KNOWN_FAILURES[ $query ] ?? false ) { + if ( self::$known_failures[ $query ] ?? false ) { if ( null !== $ast ) { $this->assertNull( $ast, "Parsing succeeded, but was expected to fail for query: $query" ); } diff --git a/packages/mysql-on-sqlite/tests/mysql/data/mysql-server-tests-known-parser-failures.php b/packages/mysql-on-sqlite/tests/mysql/data/mysql-server-tests-known-parser-failures.php new file mode 100644 index 000000000..0ed61f3c8 --- /dev/null +++ b/packages/mysql-on-sqlite/tests/mysql/data/mysql-server-tests-known-parser-failures.php @@ -0,0 +1,19 @@ + true, + 'select 1ea10.1a20,1e+ 1e+10 from 1ea10' => true, + "聠聡聢聣聤聬聭聮聯聰聲聽隆垄拢陇楼卤潞禄录陆戮 聶職聳聴\n0聲5\n1聲5\n2聲5\n3聲5\n4\n\nSET NAMES gb18030" => true, + "alter user mysqltest_7@ identified by 'systpass'" => true, + "SELECT 'a%' LIKE 'a!%' ESCAPE '!', 'a%' LIKE 'a!' || '%' ESCAPE '!'" => true, + "SELECT 'a%' NOT LIKE 'a!%' ESCAPE '!', 'a%' NOT LIKE 'a!' || '%' ESCAPE '!'" => true, + "SELECT 'a%' LIKE 'a!%' ESCAPE '$', 'a%' LIKE 'a!' || '%' ESCAPE '$'" => true, + "SELECT 'a%' NOT LIKE 'a!%' ESCAPE '$', 'a%' NOT LIKE 'a!' || '%' ESCAPE '$'" => true, + 'ALTER SCHEMA s1 READ ONLY DEFAULT' => true, +); diff --git a/packages/mysql-on-sqlite/tests/mysql/native/WP_MySQL_Parser_Instanceof_Tests.php b/packages/mysql-on-sqlite/tests/mysql/native/WP_MySQL_Parser_Instanceof_Tests.php index 0af85168e..9f9cb5e3b 100644 --- a/packages/mysql-on-sqlite/tests/mysql/native/WP_MySQL_Parser_Instanceof_Tests.php +++ b/packages/mysql-on-sqlite/tests/mysql/native/WP_MySQL_Parser_Instanceof_Tests.php @@ -11,6 +11,51 @@ * both modes. */ class WP_MySQL_Parser_Instanceof_Tests extends TestCase { + private function packed_id_stats( array $rows ): array { + return array( count( $rows ), array_sum( $rows ) ); + } + + private function packed_scalar_stats( array $rows ): array { + $descendants = intdiv( count( $rows ), 2 ); + $checksum = 0; + for ( $i = 0; $i < count( $rows ); $i += 2 ) { + $kind_id = $rows[ $i ]; + $span = $rows[ $i + 1 ]; + if ( $span < 0 ) { + $checksum += $kind_id - 1; + } else { + $checksum += $kind_id + intdiv( $span, 4294967296 ) + ( $span & 0xffffffff ); + } + } + return array( $descendants, $checksum ); + } + + private function checksum_bytes( string $bytes ): int { + $length = strlen( $bytes ); + $checksum = $length; + for ( $i = 0; $i < $length; $i++ ) { + $checksum += ord( $bytes[ $i ] ); + } + return $checksum; + } + + private function packed_scalar_token_bytes_stats( array $rows, string $sql ): array { + $descendants = intdiv( count( $rows ), 2 ); + $checksum = 0; + for ( $i = 0; $i < count( $rows ); $i += 2 ) { + $kind_id = $rows[ $i ]; + $span = $rows[ $i + 1 ]; + if ( $span < 0 ) { + $checksum += $kind_id - 1; + } else { + $start = intdiv( $span, 4294967296 ); + $length = $span & 0xffffffff; + $checksum += $kind_id + $start + $length; + $checksum += $this->checksum_bytes( substr( $sql, $start, $length ) ); + } + } + return array( $descendants, $checksum ); + } public function test_parser_is_instance_of_wp_parser(): void { $grammar = new WP_Parser_Grammar( include __DIR__ . '/../../../src/mysql/mysql-grammar.php' ); @@ -60,4 +105,339 @@ public function test_native_ast_node_identity_survives_mutation(): void { $this->assertSame( $first_child, $same_first_child ); $this->assertTrue( in_array( $synthetic, $same_first_child->get_children(), true ) ); } + + public function test_native_ast_descendant_id_rows_match_materialized_descendants(): void { + if ( ! class_exists( 'WP_MySQL_Native_Parser_Node', false ) ) { + $this->markTestSkipped( 'Native parser extension is not active.' ); + } + + $grammar = new WP_Parser_Grammar( include __DIR__ . '/../../../src/mysql/mysql-grammar.php' ); + $lexer = new WP_MySQL_Lexer( 'SELECT 1 + 2' ); + $parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + + $ast = $parser->parse(); + $this->assertInstanceOf( WP_MySQL_Native_Parser_Node::class, $ast ); + + $expected = array(); + foreach ( $ast->get_descendants() as $descendant ) { + if ( $descendant instanceof WP_Parser_Node ) { + $expected[] = 0; + $expected[] = $descendant->rule_id; + } else { + $expected[] = 1; + $expected[] = $descendant->id; + } + } + + $this->assertSame( $expected, $ast->get_native_descendant_id_rows() ); + } + + public function test_native_ast_descendant_scalar_rows_match_materialized_descendants(): void { + if ( ! class_exists( 'WP_MySQL_Native_Parser_Node', false ) ) { + $this->markTestSkipped( 'Native parser extension is not active.' ); + } + + $grammar = new WP_Parser_Grammar( include __DIR__ . '/../../../src/mysql/mysql-grammar.php' ); + $lexer = new WP_MySQL_Lexer( 'SELECT 1 + 2' ); + $parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + + $ast = $parser->parse(); + $this->assertInstanceOf( WP_MySQL_Native_Parser_Node::class, $ast ); + + $expected = array(); + foreach ( $ast->get_descendants() as $descendant ) { + if ( $descendant instanceof WP_Parser_Node ) { + $expected[] = 0; + $expected[] = $descendant->rule_id; + $expected[] = -1; + $expected[] = 0; + } else { + $expected[] = 1; + $expected[] = $descendant->id; + $expected[] = $descendant->start; + $expected[] = $descendant->length; + } + } + + $this->assertSame( $expected, $ast->get_native_descendant_scalar_rows() ); + } + + public function test_native_ast_descendant_packed_rows_match_materialized_descendants(): void { + if ( ! class_exists( 'WP_MySQL_Native_Parser_Node', false ) ) { + $this->markTestSkipped( 'Native parser extension is not active.' ); + } + + $grammar = new WP_Parser_Grammar( include __DIR__ . '/../../../src/mysql/mysql-grammar.php' ); + $lexer = new WP_MySQL_Lexer( 'SELECT 1 + 2' ); + $parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + + $ast = $parser->parse(); + $this->assertInstanceOf( WP_MySQL_Native_Parser_Node::class, $ast ); + + $expected_id_rows = array(); + $expected_scalar_rows = array(); + foreach ( $ast->get_descendants() as $descendant ) { + if ( $descendant instanceof WP_Parser_Node ) { + $expected_id_rows[] = $descendant->rule_id * 2; + $expected_scalar_rows[] = $descendant->rule_id * 2; + $expected_scalar_rows[] = -1; + } else { + $expected_id_rows[] = $descendant->id * 2 + 1; + $expected_scalar_rows[] = $descendant->id * 2 + 1; + $expected_scalar_rows[] = $descendant->start * 4294967296 + $descendant->length; + } + } + + $this->assertSame( $expected_id_rows, $ast->get_native_descendant_packed_id_rows() ); + $this->assertSame( $expected_scalar_rows, $ast->get_native_descendant_packed_scalar_rows() ); + } + + public function test_native_parser_direct_rows_match_ast_rows(): void { + if ( ! class_exists( 'WP_MySQL_Native_Parser_Node', false ) ) { + $this->markTestSkipped( 'Native parser extension is not active.' ); + } + + $grammar = new WP_Parser_Grammar( include __DIR__ . '/../../../src/mysql/mysql-grammar.php' ); + $queries = array( + 'SELECT 1 + 2', + "INSERT INTO wp_posts (ID, post_title) VALUES (1, 'Hello')", + 'CREATE TABLE t (id bigint unsigned NOT NULL AUTO_INCREMENT, PRIMARY KEY (id))', + 'SELECT * FROM t WHERE id IN (SELECT id FROM u)', + ); + $expected_batch_id = array( count( $queries ), 0, 0, 0 ); + $expected_batch_scalar = array( count( $queries ), 0, 0, 0 ); + $expected_batch_token_bytes = array( count( $queries ), 0, 0, 0 ); + foreach ( $queries as $sql ) { + $lexer = new WP_MySQL_Lexer( $sql ); + $ast_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $ast = $ast_parser->parse(); + $this->assertInstanceOf( WP_MySQL_Native_Parser_Node::class, $ast ); + $packed_scalar_rows = $ast->get_native_descendant_packed_scalar_rows(); + $id_stats = $this->packed_id_stats( $ast->get_native_descendant_packed_id_rows() ); + $scalar_stats = $this->packed_scalar_stats( $packed_scalar_rows ); + $token_bytes_stats = $this->packed_scalar_token_bytes_stats( $packed_scalar_rows, $sql ); + + $expected_batch_id[2] += $id_stats[0]; + $expected_batch_id[3] += $id_stats[1]; + $expected_batch_scalar[2] += $scalar_stats[0]; + $expected_batch_scalar[3] += $scalar_stats[1]; + $expected_batch_token_bytes[2] += $token_bytes_stats[0]; + $expected_batch_token_bytes[3] += $token_bytes_stats[1]; + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( $ast->get_native_descendant_id_rows(), $direct_parser->parse_native_descendant_id_rows() ); + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( $ast->get_native_descendant_packed_id_rows(), $direct_parser->parse_native_descendant_packed_id_rows() ); + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( $ast->get_native_descendant_scalar_rows(), $direct_parser->parse_native_descendant_scalar_rows() ); + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( $ast->get_native_descendant_packed_scalar_rows(), $direct_parser->parse_native_descendant_packed_scalar_rows() ); + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( + $id_stats, + $direct_parser->parse_native_descendant_packed_id_stats() + ); + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( + $scalar_stats, + $direct_parser->parse_native_descendant_packed_scalar_stats() + ); + + $lexer = new WP_MySQL_Lexer( $sql ); + $direct_parser = new WP_MySQL_Parser( $grammar, $lexer->native_token_stream() ); + $this->assertSame( + $token_bytes_stats, + $direct_parser->parse_native_descendant_packed_scalar_stats( true ) + ); + + $sql_parser = new WP_MySQL_Parser( $grammar, array() ); + $this->assertSame( + $id_stats, + $sql_parser->parse_sql_native_descendant_packed_id_stats( $sql ) + ); + + $sql_parser = new WP_MySQL_Parser( $grammar, array() ); + $this->assertSame( + $scalar_stats, + $sql_parser->parse_sql_native_descendant_packed_scalar_stats( $sql ) + ); + + $sql_parser = new WP_MySQL_Parser( $grammar, array() ); + $this->assertSame( + $token_bytes_stats, + $sql_parser->parse_sql_native_descendant_packed_scalar_stats( $sql, true ) + ); + } + + $sql_parser = new WP_MySQL_Parser( $grammar, array() ); + $this->assertSame( + $expected_batch_id, + $sql_parser->parse_sql_batch_native_descendant_packed_id_stats( $queries ) + ); + + $sql_parser = new WP_MySQL_Parser( $grammar, array() ); + $this->assertSame( + $expected_batch_scalar, + $sql_parser->parse_sql_batch_native_descendant_packed_scalar_stats( $queries ) + ); + + $sql_parser = new WP_MySQL_Parser( $grammar, array() ); + $this->assertSame( + $expected_batch_token_bytes, + $sql_parser->parse_sql_batch_native_descendant_packed_scalar_stats( $queries, true ) + ); + } + + public function test_native_sqlite_plan_translates_common_wordpress_queries(): void { + if ( + ! class_exists( 'WP_MySQL_Native_Lexer', false ) + || ! method_exists( 'WP_MySQL_Native_Lexer', 'translate_sqlite_plan' ) + || ! method_exists( 'WP_MySQL_Native_Lexer', 'translate_sqlite_plan_code' ) + ) { + $this->markTestSkipped( 'Native SQLite plan translator is not active.' ); + } + + $this->assertSame( + 1, + WP_MySQL_Native_Lexer::translate_sqlite_plan_code( + "SELECT ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2" + ) + ); + + $this->assertSame( + array( + 'select_passthrough', + "SELECT ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2", + "SELECT ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID", + ), + WP_MySQL_Native_Lexer::translate_sqlite_plan( + "SELECT SQL_CALC_FOUND_ROWS ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2" + ) + ); + $this->assertSame( + 0, + WP_MySQL_Native_Lexer::translate_sqlite_plan_code( + "SELECT SQL_CALC_FOUND_ROWS ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2" + ) + ); + + $this->assertSame( + array( + 'update_passthrough', + "UPDATE `wp_options` SET `option_value` = '1' WHERE `option_name` = 'x'", + ), + WP_MySQL_Native_Lexer::translate_sqlite_plan( + "UPDATE `wp_options` SET `option_value` = '1' WHERE `option_name` = 'x'" + ) + ); + $this->assertSame( + 2, + WP_MySQL_Native_Lexer::translate_sqlite_plan_code( + "UPDATE `wp_options` SET `option_value` = '1' WHERE `option_name` = 'x'" + ) + ); + + $this->assertSame( + array( + 'select_session_sql_mode', + '@@session.SQL_mode', + ), + WP_MySQL_Native_Lexer::translate_sqlite_plan( 'SELECT @@session.SQL_mode' ) + ); + } + + public function test_native_sqlite_plan_rejects_queries_that_need_mysql_translation(): void { + if ( + ! class_exists( 'WP_MySQL_Native_Lexer', false ) + || ! method_exists( 'WP_MySQL_Native_Lexer', 'translate_sqlite_plan' ) + || ! method_exists( 'WP_MySQL_Native_Lexer', 'translate_sqlite_plan_code' ) + ) { + $this->markTestSkipped( 'Native SQLite plan translator is not active.' ); + } + + $this->assertNull( + WP_MySQL_Native_Lexer::translate_sqlite_plan( 'SELECT * FROM information_schema.tables' ) + ); + $this->assertSame( + 0, + WP_MySQL_Native_Lexer::translate_sqlite_plan_code( 'SELECT * FROM information_schema.tables' ) + ); + $this->assertNull( + WP_MySQL_Native_Lexer::translate_sqlite_plan( 'SELECT CAST (meta_value AS UNSIGNED) FROM wp_postmeta' ) + ); + } + + public function test_native_sqlite_connection_fetches_rows_from_file_database(): void { + if ( ! class_exists( 'WP_SQLite_Native_Connection', false ) ) { + $this->markTestSkipped( 'Native SQLite connection is not active.' ); + } + + $db_path = tempnam( sys_get_temp_dir(), 'wp-sqlite-native-' ); + $this->assertIsString( $db_path ); + + try { + $pdo = new PDO( 'sqlite:' . $db_path ); + $pdo->exec( 'CREATE TABLE wp_posts (ID INTEGER PRIMARY KEY, post_title TEXT)' ); + $pdo->exec( "INSERT INTO wp_posts VALUES (1, 'Hello'), (2, 'World')" ); + + $connection = new WP_SQLite_Native_Connection( $db_path ); + $stmt = $connection->query( 'SELECT ID, post_title FROM wp_posts ORDER BY ID' ); + $this->assertSame( 2, $stmt->columnCount() ); + $this->assertSame( + array( + array( + 'ID' => '1', + 'post_title' => 'Hello', + ), + array( + 'ID' => '2', + 'post_title' => 'World', + ), + ), + $stmt->fetchAll( PDO::FETCH_ASSOC ) + ); + + $mysql_stmt = $connection->queryMysql( 'SELECT SQL_CALC_FOUND_ROWS ID FROM wp_posts ORDER BY ID LIMIT 1' ); + $this->assertNotNull( $mysql_stmt ); + $this->assertSame( 2, $mysql_stmt->foundRows() ); + $this->assertCount( 2, $mysql_stmt->sqliteQueries() ); + $this->assertSame( + array( + array( + 'ID' => '1', + ), + ), + $mysql_stmt->fetchAll( PDO::FETCH_ASSOC ) + ); + + $column_stmt = $connection->queryMysql( 'SELECT SQL_CALC_FOUND_ROWS ID, post_title FROM wp_posts ORDER BY ID LIMIT 1' ); + $this->assertSame( array( 'Hello' ), $column_stmt->fetchAll( PDO::FETCH_COLUMN, 1 ) ); + + $packed_result = $connection->queryMysqlPackedRows( 'SELECT SQL_CALC_FOUND_ROWS ID, post_title FROM wp_posts ORDER BY ID LIMIT 1' ); + $this->assertNotNull( $packed_result ); + $this->assertSame( 2, $packed_result->foundRows() ); + $this->assertSame( 1, $packed_result->rowCount() ); + $this->assertSame( 2, $packed_result->columnCount() ); + $this->assertSame( array( 'ID', 'post_title' ), $packed_result->columns() ); + $this->assertSame( pack( 'V', 1 ) . '1' . pack( 'V', 5 ) . 'Hello', $packed_result->packedRows() ); + $this->assertSame( pack( 'V', 1 ) . '1' . pack( 'V', 5 ) . 'Hello', $packed_result->takePackedRows() ); + $this->assertSame( '', $packed_result->packedRows() ); + + $update = $connection->executeStatement( "UPDATE wp_posts SET post_title = 'Changed' WHERE ID = 1" ); + $this->assertSame( 1, $update->rowCount() ); + } finally { + unlink( $db_path ); + } + } } diff --git a/packages/mysql-on-sqlite/tests/tools/run-parser-benchmark.php b/packages/mysql-on-sqlite/tests/tools/run-parser-benchmark.php index 25303c6a8..fa8aebd8a 100644 --- a/packages/mysql-on-sqlite/tests/tools/run-parser-benchmark.php +++ b/packages/mysql-on-sqlite/tests/tools/run-parser-benchmark.php @@ -12,6 +12,29 @@ * How much AST data to consume after parsing: * none Only require parse() to return an AST (default). * descendants Walk all descendants with get_descendants(). + * descendant-ids + * Consume all descendants as scalar kind/id rows. + * descendant-rows + * Consume all descendants as scalar kind/id/span rows. + * descendant-token-bytes + * Consume scalar rows and read each token's raw bytes. + * descendant-packed-ids + * Consume all descendants as one packed kind/id int per descendant. + * descendant-packed-rows + * Consume all descendants as packed kind/id/span rows. + * descendant-packed-token-bytes + * Consume packed rows and read each token's raw bytes. + * direct-descendant-* + * Use the native parser's direct scalar row API when available, + * skipping even the root PHP AST wrapper. + * direct-descendant-*-stats + * Use the native parser's visitor-style stats API when available, + * keeping descendant consumption in Rust. + * direct-sql-descendant-*-stats + * Use the native parser's raw-SQL stats API when available, + * keeping lexing, parsing, and descendant consumption in Rust. + * direct-sql-batch-descendant-*-stats + * Use one native call for the whole SQL corpus when available. */ // Throw exception if anything fails. @@ -33,7 +56,33 @@ function ( $severity, $message, $file, $line ) { } } -if ( ! in_array( $consume, array( 'none', 'descendants' ), true ) ) { +$consume_modes = array( + 'none', + 'descendants', + 'descendant-ids', + 'descendant-rows', + 'descendant-token-bytes', + 'descendant-packed-ids', + 'descendant-packed-rows', + 'descendant-packed-token-bytes', + 'direct-descendant-ids', + 'direct-descendant-rows', + 'direct-descendant-token-bytes', + 'direct-descendant-packed-ids', + 'direct-descendant-packed-rows', + 'direct-descendant-packed-token-bytes', + 'direct-descendant-packed-ids-stats', + 'direct-descendant-packed-rows-stats', + 'direct-descendant-packed-token-bytes-stats', + 'direct-sql-descendant-packed-ids-stats', + 'direct-sql-descendant-packed-rows-stats', + 'direct-sql-descendant-packed-token-bytes-stats', + 'direct-sql-batch-descendant-packed-ids-stats', + 'direct-sql-batch-descendant-packed-rows-stats', + 'direct-sql-batch-descendant-packed-token-bytes-stats', +); + +if ( ! in_array( $consume, $consume_modes, true ) ) { throw new InvalidArgumentException( sprintf( 'Unsupported --consume mode: %s', $consume ) ); } @@ -52,22 +101,339 @@ function get_stats( $total, $failures, $exceptions ) { ); } +function checksum_bytes( string $bytes ): int { + $length = strlen( $bytes ); + $checksum = $length; + for ( $i = 0; $i < $length; $i++ ) { + $checksum += ord( $bytes[ $i ] ); + } + return $checksum; +} + +function consume_native_descendant_id_rows( array $rows, int &$descendants, int &$checksum ): void { + $descendants += intdiv( count( $rows ), 2 ); + foreach ( $rows as $value ) { + $checksum += $value; + } +} + +function pack_kind_id( int $kind, int $id ): int { + return $id * 2 + $kind; +} + +function pack_span( int $start, int $length ): int { + return $start * 4294967296 + $length; +} + +function unpack_span_start( int $span ): int { + return intdiv( $span, 4294967296 ); +} + +function unpack_span_length( int $span ): int { + return $span & 0xffffffff; +} + +function consume_native_descendant_packed_id_rows( array $rows, int &$descendants, int &$checksum ): void { + $descendants += count( $rows ); + foreach ( $rows as $value ) { + $checksum += $value; + } +} + +function consume_native_descendant_scalar_rows( + array $rows, + string $query, + bool $consume_token_bytes, + int &$descendants, + int &$checksum +): void { + $row_count = count( $rows ); + $descendants += intdiv( $row_count, 4 ); + for ( $i = 0; $i < $row_count; $i += 4 ) { + $kind = $rows[ $i ]; + $id = $rows[ $i + 1 ]; + $start = $rows[ $i + 2 ]; + $length = $rows[ $i + 3 ]; + $checksum += $kind + $id + $start + $length; + if ( $consume_token_bytes && 1 === $kind ) { + $checksum += checksum_bytes( substr( $query, $start, $length ) ); + } + } +} + +function consume_native_descendant_packed_scalar_rows( + array $rows, + string $query, + bool $consume_token_bytes, + int &$descendants, + int &$checksum +): void { + $row_count = count( $rows ); + $descendants += intdiv( $row_count, 2 ); + for ( $i = 0; $i < $row_count; $i += 2 ) { + $kind_id = $rows[ $i ]; + $span = $rows[ $i + 1 ]; + if ( $span < 0 ) { + $checksum += $kind_id - 1; + } else { + $start = unpack_span_start( $span ); + $length = unpack_span_length( $span ); + $checksum += $kind_id + $start + $length; + } + if ( $consume_token_bytes && ( $kind_id & 1 ) === 1 ) { + $checksum += checksum_bytes( substr( $query, $start, $length ) ); + } + } +} + +function consume_native_descendant_stats( ?array $stats, int &$descendants, int &$checksum ): bool { + if ( null === $stats ) { + return false; + } + $descendants += $stats[0]; + $checksum += $stats[1]; + return true; +} + +function consume_php_descendant_id_rows( WP_Parser_Node $node, int &$descendants, int &$checksum ): void { + foreach ( $node->get_children() as $child ) { + ++$descendants; + if ( $child instanceof WP_Parser_Node ) { + $checksum += $child->rule_id; + consume_php_descendant_id_rows( $child, $descendants, $checksum ); + } else { + $checksum += 1 + $child->id; + } + } +} + +function consume_php_descendant_packed_id_rows( WP_Parser_Node $node, int &$descendants, int &$checksum ): void { + foreach ( $node->get_children() as $child ) { + ++$descendants; + if ( $child instanceof WP_Parser_Node ) { + $checksum += pack_kind_id( 0, $child->rule_id ); + consume_php_descendant_packed_id_rows( $child, $descendants, $checksum ); + } else { + $checksum += pack_kind_id( 1, $child->id ); + } + } +} + +function consume_php_descendant_scalar_rows( WP_Parser_Node $node, string $query, bool $consume_token_bytes, int &$descendants, int &$checksum ): void { + foreach ( $node->get_children() as $child ) { + ++$descendants; + if ( $child instanceof WP_Parser_Node ) { + $checksum += $child->rule_id - 1; + consume_php_descendant_scalar_rows( $child, $query, $consume_token_bytes, $descendants, $checksum ); + } else { + $checksum += 1 + $child->id + $child->start + $child->length; + if ( $consume_token_bytes ) { + $checksum += checksum_bytes( substr( $query, $child->start, $child->length ) ); + } + } + } +} + +function consume_php_descendant_packed_scalar_rows( WP_Parser_Node $node, string $query, bool $consume_token_bytes, int &$descendants, int &$checksum ): void { + foreach ( $node->get_children() as $child ) { + ++$descendants; + if ( $child instanceof WP_Parser_Node ) { + $checksum += pack_kind_id( 0, $child->rule_id ) - 1; + consume_php_descendant_packed_scalar_rows( $child, $query, $consume_token_bytes, $descendants, $checksum ); + } else { + $checksum += pack_kind_id( 1, $child->id ) + $child->start + $child->length; + if ( $consume_token_bytes ) { + $checksum += checksum_bytes( substr( $query, $child->start, $child->length ) ); + } + } + } +} + +function ast_consume_mode( string $consume ): string { + if ( 0 === strpos( $consume, 'direct-sql-batch-' ) ) { + $consume = substr( $consume, strlen( 'direct-sql-batch-' ) ); + } elseif ( 0 === strpos( $consume, 'direct-sql-' ) ) { + $consume = substr( $consume, strlen( 'direct-sql-' ) ); + } elseif ( 0 === strpos( $consume, 'direct-' ) ) { + $consume = substr( $consume, strlen( 'direct-' ) ); + } + if ( '-stats' === substr( $consume, -strlen( '-stats' ) ) ) { + $consume = substr( $consume, 0, -strlen( '-stats' ) ); + } + return $consume; +} + +function benchmark_api( string $consume ): string { + if ( ! class_exists( 'WP_MySQL_Native_Parser', false ) ) { + return 'parse'; + } + if ( 0 === strpos( $consume, 'direct-sql-batch-' ) && '-stats' === substr( $consume, -strlen( '-stats' ) ) ) { + return 'direct-native-sql-batch-stats'; + } + if ( 0 === strpos( $consume, 'direct-sql-' ) && '-stats' === substr( $consume, -strlen( '-stats' ) ) ) { + return 'direct-native-sql-stats'; + } + if ( 0 === strpos( $consume, 'direct-' ) && '-stats' === substr( $consume, -strlen( '-stats' ) ) ) { + return 'direct-native-parser-stats'; + } + if ( 0 === strpos( $consume, 'direct-' ) ) { + return 'direct-native-parser-rows'; + } + return 'parse'; +} + +function consume_direct_native_stats( WP_MySQL_Parser $parser, string $consume, int &$descendants, int &$checksum ): ?bool { + if ( 0 !== strpos( $consume, 'direct-' ) || 0 === strpos( $consume, 'direct-sql-' ) || '-stats' !== substr( $consume, -strlen( '-stats' ) ) ) { + return null; + } + + $ast_consume = ast_consume_mode( $consume ); + if ( 'descendant-packed-ids' === $ast_consume && method_exists( $parser, 'parse_native_descendant_packed_id_stats' ) ) { + return consume_native_descendant_stats( + $parser->parse_native_descendant_packed_id_stats(), + $descendants, + $checksum + ); + } + + if ( ( 'descendant-packed-rows' === $ast_consume || 'descendant-packed-token-bytes' === $ast_consume ) && method_exists( $parser, 'parse_native_descendant_packed_scalar_stats' ) ) { + return consume_native_descendant_stats( + $parser->parse_native_descendant_packed_scalar_stats( 'descendant-packed-token-bytes' === $ast_consume ), + $descendants, + $checksum + ); + } + + return null; +} + +function consume_direct_native_sql_stats( &$parser, WP_Parser_Grammar $grammar, string $consume, string $query, int &$descendants, int &$checksum ): ?bool { + if ( 0 !== strpos( $consume, 'direct-sql-' ) || 0 === strpos( $consume, 'direct-sql-batch-' ) || '-stats' !== substr( $consume, -strlen( '-stats' ) ) ) { + return null; + } + + if ( null === $parser ) { + $parser = new WP_MySQL_Parser( $grammar, array() ); + } + + $ast_consume = ast_consume_mode( $consume ); + if ( 'descendant-packed-ids' === $ast_consume && method_exists( $parser, 'parse_sql_native_descendant_packed_id_stats' ) ) { + return consume_native_descendant_stats( + $parser->parse_sql_native_descendant_packed_id_stats( $query ), + $descendants, + $checksum + ); + } + + if ( ( 'descendant-packed-rows' === $ast_consume || 'descendant-packed-token-bytes' === $ast_consume ) && method_exists( $parser, 'parse_sql_native_descendant_packed_scalar_stats' ) ) { + return consume_native_descendant_stats( + $parser->parse_sql_native_descendant_packed_scalar_stats( $query, 'descendant-packed-token-bytes' === $ast_consume ), + $descendants, + $checksum + ); + } + + return null; +} + +function consume_direct_native_sql_batch_stats( &$parser, WP_Parser_Grammar $grammar, string $consume, array $queries, array &$failures, int &$descendants, int &$checksum ): ?int { + if ( 0 !== strpos( $consume, 'direct-sql-batch-' ) || '-stats' !== substr( $consume, -strlen( '-stats' ) ) ) { + return null; + } + + if ( null === $parser ) { + $parser = new WP_MySQL_Parser( $grammar, array() ); + } + + $ast_consume = ast_consume_mode( $consume ); + if ( 'descendant-packed-ids' === $ast_consume && method_exists( $parser, 'parse_sql_batch_native_descendant_packed_id_stats' ) ) { + $stats = $parser->parse_sql_batch_native_descendant_packed_id_stats( $queries ); + } elseif ( ( 'descendant-packed-rows' === $ast_consume || 'descendant-packed-token-bytes' === $ast_consume ) && method_exists( $parser, 'parse_sql_batch_native_descendant_packed_scalar_stats' ) ) { + $stats = $parser->parse_sql_batch_native_descendant_packed_scalar_stats( $queries, 'descendant-packed-token-bytes' === $ast_consume ); + } else { + return null; + } + + for ( $i = 0; $i < $stats[1]; $i++ ) { + $failures[] = ''; + } + $descendants += $stats[2]; + $checksum += $stats[3]; + return $stats[0]; +} + +function consume_direct_native_rows( WP_MySQL_Parser $parser, string $consume, string $query, int &$descendants, int &$checksum ): ?bool { + if ( 0 !== strpos( $consume, 'direct-' ) || 0 === strpos( $consume, 'direct-sql-' ) || '-stats' === substr( $consume, -strlen( '-stats' ) ) ) { + return null; + } + + $ast_consume = ast_consume_mode( $consume ); + if ( 'descendant-ids' === $ast_consume && method_exists( $parser, 'parse_native_descendant_id_rows' ) ) { + $rows = $parser->parse_native_descendant_id_rows(); + if ( null === $rows ) { + return false; + } + consume_native_descendant_id_rows( $rows, $descendants, $checksum ); + return true; + } + + if ( 'descendant-packed-ids' === $ast_consume && method_exists( $parser, 'parse_native_descendant_packed_id_rows' ) ) { + $rows = $parser->parse_native_descendant_packed_id_rows(); + if ( null === $rows ) { + return false; + } + consume_native_descendant_packed_id_rows( $rows, $descendants, $checksum ); + return true; + } + + if ( ( 'descendant-rows' === $ast_consume || 'descendant-token-bytes' === $ast_consume ) && method_exists( $parser, 'parse_native_descendant_scalar_rows' ) ) { + $rows = $parser->parse_native_descendant_scalar_rows(); + if ( null === $rows ) { + return false; + } + consume_native_descendant_scalar_rows( $rows, $query, 'descendant-token-bytes' === $ast_consume, $descendants, $checksum ); + return true; + } + + if ( ( 'descendant-packed-rows' === $ast_consume || 'descendant-packed-token-bytes' === $ast_consume ) && method_exists( $parser, 'parse_native_descendant_packed_scalar_rows' ) ) { + $rows = $parser->parse_native_descendant_packed_scalar_rows(); + if ( null === $rows ) { + return false; + } + consume_native_descendant_packed_scalar_rows( $rows, $query, 'descendant-packed-token-bytes' === $ast_consume, $descendants, $checksum ); + return true; + } + + return null; +} + // Load the MySQL grammar. $grammar_data = include __DIR__ . '/../../src/mysql/mysql-grammar.php'; $grammar = new WP_Parser_Grammar( $grammar_data ); // Load the bounded checked-in corpus before timing so file IO is excluded // from the benchmark. -$data_dir = __DIR__ . '/../mysql/data'; -$handle = fopen( "$data_dir/mysql-server-tests-queries.csv", 'r' ); -$queries = array(); +$data_dir = __DIR__ . '/../mysql/data'; +$known_parser_failures = include "$data_dir/mysql-server-tests-known-parser-failures.php"; +$handle = fopen( "$data_dir/mysql-server-tests-queries.csv", 'r' ); +$queries = array(); +$corpus_queries = 0; +$skipped_known_failures = 0; while ( ( $record = fgetcsv( $handle, null, ',', '"', '\\' ) ) !== false ) { $query = $record[0] ?? null; if ( null === $query || '' === $query ) { continue; } + ++$corpus_queries; + if ( $known_parser_failures[ $query ] ?? false ) { + ++$skipped_known_failures; + if ( null !== $limit && $corpus_queries >= $limit ) { + break; + } + continue; + } $queries[] = $query; - if ( null !== $limit && count( $queries ) >= $limit ) { + if ( null !== $limit && $corpus_queries >= $limit ) { break; } } @@ -77,39 +443,140 @@ function get_stats( $total, $failures, $exceptions ) { $exceptions = array(); $processed = 0; $descendants = 0; +$checksum = 0; // Reuse a single parser across queries, mirroring the driver // (WP_PDO_MySQL_On_SQLite::reset_or_create_parser), which resets tokens on the // same instance rather than constructing a fresh parser per query. -$parser = null; -$start = microtime( true ); -foreach ( $queries as $query ) { - try { - $lexer = new WP_MySQL_Lexer( $query ); - $tokens = $lexer instanceof WP_MySQL_Native_Lexer - ? $lexer->native_token_stream() - : $lexer->remaining_tokens(); - if ( ( is_array( $tokens ) ? count( $tokens ) : $tokens->count() ) === 0 ) { - throw new Exception( 'Failed to tokenize query: ' . $query ); - } +$parser = null; +$start = microtime( true ); +$batch_processed = consume_direct_native_sql_batch_stats( + $parser, + $grammar, + $consume, + $queries, + $failures, + $descendants, + $checksum +); +if ( null !== $batch_processed ) { + $processed = $batch_processed; +} else { + foreach ( $queries as $query ) { + try { + $direct_sql_stats_consumed = consume_direct_native_sql_stats( + $parser, + $grammar, + $consume, + $query, + $descendants, + $checksum + ); + if ( false === $direct_sql_stats_consumed ) { + $failures[] = $query; + } elseif ( true !== $direct_sql_stats_consumed ) { + $lexer = new WP_MySQL_Lexer( $query ); + $tokens = $lexer instanceof WP_MySQL_Native_Lexer + ? $lexer->native_token_stream() + : $lexer->remaining_tokens(); + if ( ( is_array( $tokens ) ? count( $tokens ) : $tokens->count() ) === 0 ) { + throw new Exception( 'Failed to tokenize query: ' . $query ); + } - if ( null === $parser ) { - $parser = new WP_MySQL_Parser( $grammar, $tokens ); - } else { - $parser->reset_tokens( $tokens ); - } - $ast = $parser->parse(); - if ( null === $ast ) { - $failures[] = $query; - } elseif ( 'descendants' === $consume ) { - $descendants += count( $ast->get_descendants() ); + if ( null === $parser ) { + $parser = new WP_MySQL_Parser( $grammar, $tokens ); + } else { + $parser->reset_tokens( $tokens ); + } + + $direct_stats_consumed = consume_direct_native_stats( + $parser, + $consume, + $descendants, + $checksum + ); + $direct_rows_consumed = true === $direct_stats_consumed + ? true + : consume_direct_native_rows( + $parser, + $consume, + $query, + $descendants, + $checksum + ); + if ( false === $direct_stats_consumed || false === $direct_rows_consumed ) { + $failures[] = $query; + } elseif ( true !== $direct_rows_consumed ) { + $ast_consume = ast_consume_mode( $consume ); + $ast = $parser->parse(); + if ( null === $ast ) { + $failures[] = $query; + } elseif ( 'descendants' === $ast_consume ) { + $descendants += count( $ast->get_descendants() ); + } elseif ( 'descendant-ids' === $ast_consume ) { + if ( + class_exists( 'WP_MySQL_Native_Parser_Node', false ) + && $ast instanceof WP_MySQL_Native_Parser_Node + && method_exists( $ast, 'get_native_descendant_id_rows' ) + ) { + consume_native_descendant_id_rows( $ast->get_native_descendant_id_rows(), $descendants, $checksum ); + } else { + consume_php_descendant_id_rows( $ast, $descendants, $checksum ); + } + } elseif ( 'descendant-rows' === $ast_consume || 'descendant-token-bytes' === $ast_consume ) { + $consume_token_bytes = 'descendant-token-bytes' === $ast_consume; + if ( + class_exists( 'WP_MySQL_Native_Parser_Node', false ) + && $ast instanceof WP_MySQL_Native_Parser_Node + && method_exists( $ast, 'get_native_descendant_scalar_rows' ) + ) { + consume_native_descendant_scalar_rows( + $ast->get_native_descendant_scalar_rows(), + $query, + $consume_token_bytes, + $descendants, + $checksum + ); + } else { + consume_php_descendant_scalar_rows( $ast, $query, $consume_token_bytes, $descendants, $checksum ); + } + } elseif ( 'descendant-packed-ids' === $ast_consume ) { + if ( + class_exists( 'WP_MySQL_Native_Parser_Node', false ) + && $ast instanceof WP_MySQL_Native_Parser_Node + && method_exists( $ast, 'get_native_descendant_packed_id_rows' ) + ) { + consume_native_descendant_packed_id_rows( $ast->get_native_descendant_packed_id_rows(), $descendants, $checksum ); + } else { + consume_php_descendant_packed_id_rows( $ast, $descendants, $checksum ); + } + } elseif ( 'descendant-packed-rows' === $ast_consume || 'descendant-packed-token-bytes' === $ast_consume ) { + $consume_token_bytes = 'descendant-packed-token-bytes' === $ast_consume; + if ( + class_exists( 'WP_MySQL_Native_Parser_Node', false ) + && $ast instanceof WP_MySQL_Native_Parser_Node + && method_exists( $ast, 'get_native_descendant_packed_scalar_rows' ) + ) { + consume_native_descendant_packed_scalar_rows( + $ast->get_native_descendant_packed_scalar_rows(), + $query, + $consume_token_bytes, + $descendants, + $checksum + ); + } else { + consume_php_descendant_packed_scalar_rows( $ast, $query, $consume_token_bytes, $descendants, $checksum ); + } + } + } + } + } catch ( Exception $e ) { + $exceptions[] = $query; } - } catch ( Exception $e ) { - $exceptions[] = $query; - } - $processed += 1; - if ( ! $json && $processed > 0 && 0 === $processed % 1000 ) { - echo get_stats( $processed, count( $failures ), count( $exceptions ) ), "\n"; + $processed += 1; + if ( ! $json && $processed > 0 && 0 === $processed % 1000 ) { + echo get_stats( $processed, count( $failures ), count( $exceptions ) ), "\n"; + } } } $duration = microtime( true ) - $start; @@ -118,17 +585,21 @@ function get_stats( $total, $failures, $exceptions ) { if ( $json ) { echo json_encode( array( - 'benchmark' => 'mysql-parser', - 'implementation' => class_exists( 'WP_MySQL_Native_Parser', false ) ? 'native-extension' : 'php', - 'extension_loaded' => extension_loaded( 'wp_mysql_parser' ), - 'queries' => $processed, - 'consume' => $consume, - 'descendants' => $descendants, - 'duration' => $duration, - 'qps' => $qps, - 'failures' => count( $failures ), - 'exceptions' => count( $exceptions ), - 'php_version' => PHP_VERSION, + 'benchmark' => 'mysql-parser', + 'implementation' => class_exists( 'WP_MySQL_Native_Parser', false ) ? 'native-extension' : 'php', + 'api' => benchmark_api( $consume ), + 'extension_loaded' => extension_loaded( 'wp_mysql_parser' ), + 'queries' => $processed, + 'corpus_queries' => $corpus_queries, + 'skipped_known_failures' => $skipped_known_failures, + 'consume' => $consume, + 'descendants' => $descendants, + 'checksum' => $checksum, + 'duration' => $duration, + 'qps' => $qps, + 'failures' => count( $failures ), + 'exceptions' => count( $exceptions ), + 'php_version' => PHP_VERSION, ), JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES ), "\n"; @@ -136,11 +607,15 @@ function get_stats( $total, $failures, $exceptions ) { } echo get_stats( $processed, count( $failures ), count( $exceptions ) ), "\n"; -printf( "AST consumption: %s", $consume ); -if ( 'descendants' === $consume ) { - printf( " (%d descendants)", $descendants ); +printf( 'AST consumption: %s', $consume ); +$ast_consume = ast_consume_mode( $consume ); +if ( 'descendants' === $ast_consume || 'descendant-ids' === $ast_consume || 'descendant-rows' === $ast_consume || 'descendant-token-bytes' === $ast_consume || 'descendant-packed-ids' === $ast_consume || 'descendant-packed-rows' === $ast_consume || 'descendant-packed-token-bytes' === $ast_consume ) { + printf( ' (%d descendants, checksum %d)', $descendants, $checksum ); } echo "\n"; +if ( $skipped_known_failures > 0 ) { + printf( "Skipped known parser corpus failures: %d / %d\n", $skipped_known_failures, $corpus_queries ); +} // Print the results. printf( "\nParsed %d queries in %.5fs @ %d QPS.\n", $processed, $duration, $qps ); diff --git a/packages/mysql-on-sqlite/tests/tools/run-sqlite-execution-benchmark.php b/packages/mysql-on-sqlite/tests/tools/run-sqlite-execution-benchmark.php new file mode 100644 index 000000000..46bcd2d1d --- /dev/null +++ b/packages/mysql-on-sqlite/tests/tools/run-sqlite-execution-benchmark.php @@ -0,0 +1,258 @@ +setAttribute( PDO::ATTR_STRINGIFY_FETCHES, true ); + $driver->query( + 'CREATE TABLE wp_posts (' . + 'ID INTEGER PRIMARY KEY, ' . + 'post_status TEXT NOT NULL, ' . + 'post_title TEXT NOT NULL, ' . + 'menu_order INTEGER NOT NULL DEFAULT 0' . + ')' + ); + + for ( $i = 1; $i <= $row_count; $i++ ) { + $status = 0 === $i % 3 ? 'draft' : 'publish'; + $driver->query( + sprintf( + "INSERT INTO wp_posts (ID, post_status, post_title, menu_order) VALUES (%d, '%s', 'Post %d', 0)", + $i, + $status, + $i + ) + ); + } + + return $driver; +} + +function sqlite_execution_benchmark_select_found_rows( WP_PDO_MySQL_On_SQLite $driver, int $expected_found_rows, int $select_limit ): int { + $stmt = $driver->query( + sprintf( + "SELECT SQL_CALC_FOUND_ROWS ID, post_title FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT %d", + $select_limit + ), + PDO::FETCH_ASSOC + ); + $rows = $stmt->fetchAll(); + $expected_rows = min( $select_limit, $expected_found_rows ); + if ( count( $rows ) !== $expected_rows ) { + throw new RuntimeException( sprintf( 'Expected %d rows, got %d.', $expected_rows, count( $rows ) ) ); + } + $found_rows = (int) $driver->query( 'SELECT FOUND_ROWS()' )->fetchColumn(); + if ( $expected_found_rows !== $found_rows ) { + throw new RuntimeException( sprintf( 'Expected %d FOUND_ROWS(), got %d.', $expected_found_rows, $found_rows ) ); + } + + return $found_rows + (int) $rows[0]['ID'] + strlen( $rows[0]['post_title'] ); +} + +function sqlite_execution_benchmark_checksum_packed_rows( string $packed_rows, int $found_rows, int $row_count, int $column_count ): int { + $checksum = $found_rows + $row_count + $column_count; + $length = strlen( $packed_rows ); + for ( $i = 0; $i < $length; $i++ ) { + $checksum += ord( $packed_rows[ $i ] ); + } + return $checksum; +} + +function sqlite_execution_benchmark_pack_value( $value ): string { + if ( null === $value ) { + return pack( 'V', 0xffffffff ); + } + + $bytes = (string) $value; + return pack( 'V', strlen( $bytes ) ) . $bytes; +} + +function sqlite_execution_benchmark_pack_rows( array $rows ): string { + $packed_rows = ''; + foreach ( $rows as $row ) { + foreach ( $row as $value ) { + $packed_rows .= sqlite_execution_benchmark_pack_value( $value ); + } + } + return $packed_rows; +} + +function sqlite_execution_benchmark_packed_select_found_rows( + WP_PDO_MySQL_On_SQLite $driver, + ?object $native_connection, + int $expected_found_rows, + int $select_limit +): int { + $sql = sprintf( + "SELECT SQL_CALC_FOUND_ROWS ID, post_title FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT %d", + $select_limit + ); + $expected_rows = min( $select_limit, $expected_found_rows ); + + if ( null !== $native_connection ) { + $result = $native_connection->queryMysqlPackedRows( $sql ); + if ( ! $result ) { + throw new RuntimeException( 'Native packed query was not handled.' ); + } + if ( $expected_found_rows !== $result->foundRows() ) { + throw new RuntimeException( + sprintf( 'Expected %d native packed FOUND_ROWS(), got %d.', $expected_found_rows, $result->foundRows() ) + ); + } + if ( $expected_rows !== $result->rowCount() || 2 !== $result->columnCount() ) { + throw new RuntimeException( 'Unexpected native packed result shape.' ); + } + + $packed_rows = method_exists( $result, 'takePackedRows' ) ? $result->takePackedRows() : $result->packedRows(); + return $result->checksum() + strlen( $packed_rows ); + } + + $stmt = $driver->query( $sql, PDO::FETCH_NUM ); + $rows = $stmt->fetchAll(); + if ( count( $rows ) !== $expected_rows ) { + throw new RuntimeException( sprintf( 'Expected %d rows, got %d.', $expected_rows, count( $rows ) ) ); + } + $found_rows = (int) $driver->query( 'SELECT FOUND_ROWS()' )->fetchColumn(); + if ( $expected_found_rows !== $found_rows ) { + throw new RuntimeException( sprintf( 'Expected %d FOUND_ROWS(), got %d.', $expected_found_rows, $found_rows ) ); + } + + $packed_rows = sqlite_execution_benchmark_pack_rows( $rows ); + return sqlite_execution_benchmark_checksum_packed_rows( $packed_rows, $found_rows, count( $rows ), 2 ) + strlen( $packed_rows ); +} + +function sqlite_execution_benchmark_update( WP_PDO_MySQL_On_SQLite $driver ): int { + $stmt = $driver->query( 'UPDATE wp_posts SET menu_order = menu_order + 1 WHERE ID = 1' ); + return $stmt->rowCount(); +} + +function sqlite_execution_benchmark_run_workload( + WP_PDO_MySQL_On_SQLite $driver, + ?object $native_connection, + string $workload, + int $expected_found_rows, + int $select_limit, + int $iterations +): int { + $checksum = 0; + for ( $i = 0; $i < $iterations; $i++ ) { + if ( 'select-found-rows' === $workload || 'mixed' === $workload ) { + $checksum += sqlite_execution_benchmark_select_found_rows( $driver, $expected_found_rows, $select_limit ); + } + if ( 'packed-select-found-rows' === $workload ) { + $checksum += sqlite_execution_benchmark_packed_select_found_rows( $driver, $native_connection, $expected_found_rows, $select_limit ); + } + if ( 'update' === $workload || 'mixed' === $workload ) { + $checksum += sqlite_execution_benchmark_update( $driver ); + } + } + return $checksum; +} + +$db_path = tempnam( sys_get_temp_dir(), 'wp-sqlite-exec-bench-' ); +if ( ! is_string( $db_path ) ) { + throw new RuntimeException( 'Unable to create temporary SQLite database path.' ); +} + +try { + $driver = sqlite_execution_benchmark_driver( $db_path, $row_count ); + $native_connection = class_exists( 'WP_SQLite_Native_Connection', false ) ? new WP_SQLite_Native_Connection( $db_path ) : null; + $expected_found_rows = $row_count - intdiv( $row_count, 3 ); + + sqlite_execution_benchmark_run_workload( $driver, $native_connection, $workload, $expected_found_rows, $select_limit, $warmup ); + + $start = hrtime( true ); + $checksum = sqlite_execution_benchmark_run_workload( $driver, $native_connection, $workload, $expected_found_rows, $select_limit, $iterations ); + $duration = ( hrtime( true ) - $start ) / 1_000_000_000; +} finally { + unlink( $db_path ); +} + +$queries_per_iteration = 'mixed' === $workload ? 3 : ( 'select-found-rows' === $workload ? 2 : 1 ); +$result = array( + 'benchmark' => 'sqlite-execution-hot-path', + 'implementation' => class_exists( 'WP_MySQL_Native_Parser', false ) ? 'native-extension' : 'php', + 'native_sqlite' => class_exists( 'WP_SQLite_Native_Connection', false ), + 'extension_loaded' => extension_loaded( 'wp_mysql_parser' ), + 'workload' => $workload, + 'iterations' => $iterations, + 'warmup' => $warmup, + 'rows' => $row_count, + 'select_limit' => $select_limit, + 'queries_per_iteration' => $queries_per_iteration, + 'logical_queries' => $iterations * $queries_per_iteration, + 'expected_found_rows' => $expected_found_rows, + 'checksum' => $checksum, + 'duration' => $duration, + 'iterations_per_second' => $iterations / $duration, + 'logical_queries_per_second' => ( $iterations * $queries_per_iteration ) / $duration, + 'php_version' => PHP_VERSION, +); + +if ( $json ) { + echo json_encode( $result, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES ), "\n"; + exit; +} + +printf( + "%s %s: %.5fs, %.0f iterations/s, %.0f logical queries/s, checksum %d\n", + $result['implementation'], + $result['workload'], + $result['duration'], + $result['iterations_per_second'], + $result['logical_queries_per_second'], + $result['checksum'] +); diff --git a/packages/php-ext-wp-mysql-parser/Cargo.lock b/packages/php-ext-wp-mysql-parser/Cargo.lock index c027761e4..737921413 100644 --- a/packages/php-ext-wp-mysql-parser/Cargo.lock +++ b/packages/php-ext-wp-mysql-parser/Cargo.lock @@ -468,6 +468,18 @@ dependencies = [ "syn", ] +[[package]] +name = "fallible-iterator" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649" + +[[package]] +name = "fallible-streaming-iterator" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a" + [[package]] name = "fastrand" version = "2.4.1" @@ -497,6 +509,12 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + [[package]] name = "foreign-types" version = "0.3.2" @@ -561,7 +579,16 @@ version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" dependencies = [ - "foldhash", + "foldhash 0.1.5", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "foldhash 0.2.0", ] [[package]] @@ -715,6 +742,16 @@ dependencies = [ "windows-link", ] +[[package]] +name = "libsqlite3-sys" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f111c8c41e7c61a49cd34e44c7619462967221a6443b0ec299e0ac30cfb9b1" +dependencies = [ + "pkg-config", + "vcpkg", +] + [[package]] name = "linux-raw-sys" version = "0.12.1" @@ -1024,6 +1061,30 @@ version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" +[[package]] +name = "rsqlite-vfs" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c" +dependencies = [ + "hashbrown 0.16.1", + "thiserror", +] + +[[package]] +name = "rusqlite" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0d2b0146dd9661bf67bb107c0bb2a55064d556eeb3fc314151b957f313bcd4e" +dependencies = [ + "bitflags", + "fallible-iterator", + "fallible-streaming-iterator", + "libsqlite3-sys", + "smallvec", + "sqlite-wasm-rs", +] + [[package]] name = "rustc-hash" version = "2.1.2" @@ -1213,6 +1274,18 @@ version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +[[package]] +name = "sqlite-wasm-rs" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc3efc0da82635d7e1ced0053bbbfa8c7ab9645d0bf36ceb4f7127bb85315d75" +dependencies = [ + "cc", + "js-sys", + "rsqlite-vfs", + "wasm-bindgen", +] + [[package]] name = "stacker" version = "0.1.24" @@ -1256,6 +1329,26 @@ dependencies = [ "windows-sys", ] +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "time" version = "0.3.47" @@ -1599,7 +1692,9 @@ name = "wp_mysql_parser" version = "0.2.0" dependencies = [ "ext-php-rs", + "itoa", "libc", + "rusqlite", "stacker", ] diff --git a/packages/php-ext-wp-mysql-parser/Cargo.toml b/packages/php-ext-wp-mysql-parser/Cargo.toml index 57465d0aa..d55552c51 100644 --- a/packages/php-ext-wp-mysql-parser/Cargo.toml +++ b/packages/php-ext-wp-mysql-parser/Cargo.toml @@ -9,7 +9,9 @@ crate-type = ["cdylib"] [dependencies] ext-php-rs = { version = "0.15.12", default-features = false, features = ["runtime"] } +itoa = "1" libc = "0.2" +rusqlite = { version = "0.39", default-features = false } stacker = "0.1" [profile.release] diff --git a/packages/php-ext-wp-mysql-parser/src/compiled_packed_id_parser.rs b/packages/php-ext-wp-mysql-parser/src/compiled_packed_id_parser.rs new file mode 100644 index 000000000..7d5ad6b89 --- /dev/null +++ b/packages/php-ext-wp-mysql-parser/src/compiled_packed_id_parser.rs @@ -0,0 +1,98469 @@ +// This file is generated from packages/mysql-on-sqlite/src/mysql/mysql-grammar.php. +// Regenerate with packages/php-ext-wp-mysql-parser/tools/generate-compiled-packed-id-parser.php. +#![allow(unused_mut, unused_variables)] + +use super::lex; +use super::native_ast_pack_kind_id; + +pub const HIGHEST_TERMINAL_ID: i64 = 1999i64; +pub const QUERY_RULE_ID: i64 = 2000i64; +pub const SELECT_STATEMENT_RULE_ID: i64 = 2461i64; + +#[derive(Clone, Copy, PartialEq, Eq)] +enum CompiledMatch { + No, + Empty, + Match, +} + +pub struct CompiledPackedIdStatsParser<'a> { + token_ids: &'a [i64], + position: usize, + descendants: i64, + checksum: i64, +} + +impl<'a> CompiledPackedIdStatsParser<'a> { + pub fn new(token_ids: &'a [i64]) -> Self { + Self { + token_ids, + position: 0, + descendants: 0, + checksum: 0, + } + } + + pub fn parse(mut self) -> Option<(i64, i64)> { + match self.parse_rule(QUERY_RULE_ID, true) { + CompiledMatch::No => None, + CompiledMatch::Empty | CompiledMatch::Match => Some((self.descendants, self.checksum)), + } + } + + fn current_token_id(&self) -> i64 { + self.token_ids.get(self.position).copied().unwrap_or(0) + } + + fn state(&self) -> (usize, i64, i64) { + (self.position, self.descendants, self.checksum) + } + + fn restore(&mut self, state: (usize, i64, i64)) { + self.position = state.0; + self.descendants = state.1; + self.checksum = state.2; + } + + fn push_node(&mut self, rule_id: i64) { + self.descendants += 1; + self.checksum += native_ast_pack_kind_id(0, rule_id); + } + + fn push_token(&mut self, token_id: i64) { + self.descendants += 1; + self.checksum += native_ast_pack_kind_id(1, token_id); + } + + fn parse_symbol(&mut self, symbol_id: i64) -> CompiledMatch { + if symbol_id <= HIGHEST_TERMINAL_ID { + if self.position >= self.token_ids.len() { + return CompiledMatch::No; + } + if symbol_id == 0 { + return CompiledMatch::Empty; + } + if self.token_ids[self.position] == symbol_id { + self.position += 1; + self.push_token(symbol_id); + return CompiledMatch::Match; + } + return CompiledMatch::No; + } + self.parse_rule(symbol_id, false) + } + + fn parse_child(&mut self, symbol_id: i64, branch_matches: &mut bool, has_children: &mut bool) { + if !*branch_matches { + return; + } + let child_starting_descendants = self.descendants; + match self.parse_symbol(symbol_id) { + CompiledMatch::No => *branch_matches = false, + CompiledMatch::Empty => {} + CompiledMatch::Match => { + if self.descendants != child_starting_descendants { + *has_children = true; + } + } + } + } + + fn parse_rule(&mut self, rule_id: i64, skip_current_node: bool) -> CompiledMatch { + match rule_id { + 2000i64 => self.parse_rule_2000(skip_current_node), + 2001i64 => self.parse_rule_2001(skip_current_node), + 2002i64 => self.parse_rule_2002(skip_current_node), + 2003i64 => self.parse_rule_2003(skip_current_node), + 2004i64 => self.parse_rule_2004(skip_current_node), + 2005i64 => self.parse_rule_2005(skip_current_node), + 2006i64 => self.parse_rule_2006(skip_current_node), + 2007i64 => self.parse_rule_2007(skip_current_node), + 2008i64 => self.parse_rule_2008(skip_current_node), + 2009i64 => self.parse_rule_2009(skip_current_node), + 2010i64 => self.parse_rule_2010(skip_current_node), + 2011i64 => self.parse_rule_2011(skip_current_node), + 2012i64 => self.parse_rule_2012(skip_current_node), + 2013i64 => self.parse_rule_2013(skip_current_node), + 2014i64 => self.parse_rule_2014(skip_current_node), + 2015i64 => self.parse_rule_2015(skip_current_node), + 2016i64 => self.parse_rule_2016(skip_current_node), + 2017i64 => self.parse_rule_2017(skip_current_node), + 2018i64 => self.parse_rule_2018(skip_current_node), + 2019i64 => self.parse_rule_2019(skip_current_node), + 2020i64 => self.parse_rule_2020(skip_current_node), + 2021i64 => self.parse_rule_2021(skip_current_node), + 2022i64 => self.parse_rule_2022(skip_current_node), + 2023i64 => self.parse_rule_2023(skip_current_node), + 2024i64 => self.parse_rule_2024(skip_current_node), + 2025i64 => self.parse_rule_2025(skip_current_node), + 2026i64 => self.parse_rule_2026(skip_current_node), + 2027i64 => self.parse_rule_2027(skip_current_node), + 2028i64 => self.parse_rule_2028(skip_current_node), + 2029i64 => self.parse_rule_2029(skip_current_node), + 2030i64 => self.parse_rule_2030(skip_current_node), + 2031i64 => self.parse_rule_2031(skip_current_node), + 2032i64 => self.parse_rule_2032(skip_current_node), + 2033i64 => self.parse_rule_2033(skip_current_node), + 2034i64 => self.parse_rule_2034(skip_current_node), + 2035i64 => self.parse_rule_2035(skip_current_node), + 2036i64 => self.parse_rule_2036(skip_current_node), + 2037i64 => self.parse_rule_2037(skip_current_node), + 2038i64 => self.parse_rule_2038(skip_current_node), + 2039i64 => self.parse_rule_2039(skip_current_node), + 2040i64 => self.parse_rule_2040(skip_current_node), + 2041i64 => self.parse_rule_2041(skip_current_node), + 2042i64 => self.parse_rule_2042(skip_current_node), + 2043i64 => self.parse_rule_2043(skip_current_node), + 2044i64 => self.parse_rule_2044(skip_current_node), + 2045i64 => self.parse_rule_2045(skip_current_node), + 2046i64 => self.parse_rule_2046(skip_current_node), + 2047i64 => self.parse_rule_2047(skip_current_node), + 2048i64 => self.parse_rule_2048(skip_current_node), + 2049i64 => self.parse_rule_2049(skip_current_node), + 2050i64 => self.parse_rule_2050(skip_current_node), + 2051i64 => self.parse_rule_2051(skip_current_node), + 2052i64 => self.parse_rule_2052(skip_current_node), + 2053i64 => self.parse_rule_2053(skip_current_node), + 2054i64 => self.parse_rule_2054(skip_current_node), + 2055i64 => self.parse_rule_2055(skip_current_node), + 2056i64 => self.parse_rule_2056(skip_current_node), + 2057i64 => self.parse_rule_2057(skip_current_node), + 2058i64 => self.parse_rule_2058(skip_current_node), + 2059i64 => self.parse_rule_2059(skip_current_node), + 2060i64 => self.parse_rule_2060(skip_current_node), + 2061i64 => self.parse_rule_2061(skip_current_node), + 2062i64 => self.parse_rule_2062(skip_current_node), + 2063i64 => self.parse_rule_2063(skip_current_node), + 2064i64 => self.parse_rule_2064(skip_current_node), + 2065i64 => self.parse_rule_2065(skip_current_node), + 2066i64 => self.parse_rule_2066(skip_current_node), + 2067i64 => self.parse_rule_2067(skip_current_node), + 2068i64 => self.parse_rule_2068(skip_current_node), + 2069i64 => self.parse_rule_2069(skip_current_node), + 2070i64 => self.parse_rule_2070(skip_current_node), + 2071i64 => self.parse_rule_2071(skip_current_node), + 2072i64 => self.parse_rule_2072(skip_current_node), + 2073i64 => self.parse_rule_2073(skip_current_node), + 2074i64 => self.parse_rule_2074(skip_current_node), + 2075i64 => self.parse_rule_2075(skip_current_node), + 2076i64 => self.parse_rule_2076(skip_current_node), + 2077i64 => self.parse_rule_2077(skip_current_node), + 2078i64 => self.parse_rule_2078(skip_current_node), + 2079i64 => self.parse_rule_2079(skip_current_node), + 2080i64 => self.parse_rule_2080(skip_current_node), + 2081i64 => self.parse_rule_2081(skip_current_node), + 2082i64 => self.parse_rule_2082(skip_current_node), + 2083i64 => self.parse_rule_2083(skip_current_node), + 2084i64 => self.parse_rule_2084(skip_current_node), + 2085i64 => self.parse_rule_2085(skip_current_node), + 2086i64 => self.parse_rule_2086(skip_current_node), + 2087i64 => self.parse_rule_2087(skip_current_node), + 2088i64 => self.parse_rule_2088(skip_current_node), + 2089i64 => self.parse_rule_2089(skip_current_node), + 2090i64 => self.parse_rule_2090(skip_current_node), + 2091i64 => self.parse_rule_2091(skip_current_node), + 2092i64 => self.parse_rule_2092(skip_current_node), + 2093i64 => self.parse_rule_2093(skip_current_node), + 2094i64 => self.parse_rule_2094(skip_current_node), + 2095i64 => self.parse_rule_2095(skip_current_node), + 2096i64 => self.parse_rule_2096(skip_current_node), + 2097i64 => self.parse_rule_2097(skip_current_node), + 2098i64 => self.parse_rule_2098(skip_current_node), + 2099i64 => self.parse_rule_2099(skip_current_node), + 2100i64 => self.parse_rule_2100(skip_current_node), + 2101i64 => self.parse_rule_2101(skip_current_node), + 2102i64 => self.parse_rule_2102(skip_current_node), + 2103i64 => self.parse_rule_2103(skip_current_node), + 2104i64 => self.parse_rule_2104(skip_current_node), + 2105i64 => self.parse_rule_2105(skip_current_node), + 2106i64 => self.parse_rule_2106(skip_current_node), + 2107i64 => self.parse_rule_2107(skip_current_node), + 2108i64 => self.parse_rule_2108(skip_current_node), + 2109i64 => self.parse_rule_2109(skip_current_node), + 2110i64 => self.parse_rule_2110(skip_current_node), + 2111i64 => self.parse_rule_2111(skip_current_node), + 2112i64 => self.parse_rule_2112(skip_current_node), + 2113i64 => self.parse_rule_2113(skip_current_node), + 2114i64 => self.parse_rule_2114(skip_current_node), + 2115i64 => self.parse_rule_2115(skip_current_node), + 2116i64 => self.parse_rule_2116(skip_current_node), + 2117i64 => self.parse_rule_2117(skip_current_node), + 2118i64 => self.parse_rule_2118(skip_current_node), + 2119i64 => self.parse_rule_2119(skip_current_node), + 2120i64 => self.parse_rule_2120(skip_current_node), + 2121i64 => self.parse_rule_2121(skip_current_node), + 2122i64 => self.parse_rule_2122(skip_current_node), + 2123i64 => self.parse_rule_2123(skip_current_node), + 2124i64 => self.parse_rule_2124(skip_current_node), + 2125i64 => self.parse_rule_2125(skip_current_node), + 2126i64 => self.parse_rule_2126(skip_current_node), + 2127i64 => self.parse_rule_2127(skip_current_node), + 2128i64 => self.parse_rule_2128(skip_current_node), + 2129i64 => self.parse_rule_2129(skip_current_node), + 2130i64 => self.parse_rule_2130(skip_current_node), + 2131i64 => self.parse_rule_2131(skip_current_node), + 2132i64 => self.parse_rule_2132(skip_current_node), + 2133i64 => self.parse_rule_2133(skip_current_node), + 2134i64 => self.parse_rule_2134(skip_current_node), + 2135i64 => self.parse_rule_2135(skip_current_node), + 2136i64 => self.parse_rule_2136(skip_current_node), + 2137i64 => self.parse_rule_2137(skip_current_node), + 2138i64 => self.parse_rule_2138(skip_current_node), + 2139i64 => self.parse_rule_2139(skip_current_node), + 2140i64 => self.parse_rule_2140(skip_current_node), + 2141i64 => self.parse_rule_2141(skip_current_node), + 2142i64 => self.parse_rule_2142(skip_current_node), + 2143i64 => self.parse_rule_2143(skip_current_node), + 2144i64 => self.parse_rule_2144(skip_current_node), + 2145i64 => self.parse_rule_2145(skip_current_node), + 2146i64 => self.parse_rule_2146(skip_current_node), + 2147i64 => self.parse_rule_2147(skip_current_node), + 2148i64 => self.parse_rule_2148(skip_current_node), + 2149i64 => self.parse_rule_2149(skip_current_node), + 2150i64 => self.parse_rule_2150(skip_current_node), + 2151i64 => self.parse_rule_2151(skip_current_node), + 2152i64 => self.parse_rule_2152(skip_current_node), + 2153i64 => self.parse_rule_2153(skip_current_node), + 2154i64 => self.parse_rule_2154(skip_current_node), + 2155i64 => self.parse_rule_2155(skip_current_node), + 2156i64 => self.parse_rule_2156(skip_current_node), + 2157i64 => self.parse_rule_2157(skip_current_node), + 2158i64 => self.parse_rule_2158(skip_current_node), + 2159i64 => self.parse_rule_2159(skip_current_node), + 2160i64 => self.parse_rule_2160(skip_current_node), + 2161i64 => self.parse_rule_2161(skip_current_node), + 2162i64 => self.parse_rule_2162(skip_current_node), + 2163i64 => self.parse_rule_2163(skip_current_node), + 2164i64 => self.parse_rule_2164(skip_current_node), + 2165i64 => self.parse_rule_2165(skip_current_node), + 2166i64 => self.parse_rule_2166(skip_current_node), + 2167i64 => self.parse_rule_2167(skip_current_node), + 2168i64 => self.parse_rule_2168(skip_current_node), + 2169i64 => self.parse_rule_2169(skip_current_node), + 2170i64 => self.parse_rule_2170(skip_current_node), + 2171i64 => self.parse_rule_2171(skip_current_node), + 2172i64 => self.parse_rule_2172(skip_current_node), + 2173i64 => self.parse_rule_2173(skip_current_node), + 2174i64 => self.parse_rule_2174(skip_current_node), + 2175i64 => self.parse_rule_2175(skip_current_node), + 2176i64 => self.parse_rule_2176(skip_current_node), + 2177i64 => self.parse_rule_2177(skip_current_node), + 2178i64 => self.parse_rule_2178(skip_current_node), + 2179i64 => self.parse_rule_2179(skip_current_node), + 2180i64 => self.parse_rule_2180(skip_current_node), + 2181i64 => self.parse_rule_2181(skip_current_node), + 2182i64 => self.parse_rule_2182(skip_current_node), + 2183i64 => self.parse_rule_2183(skip_current_node), + 2184i64 => self.parse_rule_2184(skip_current_node), + 2185i64 => self.parse_rule_2185(skip_current_node), + 2186i64 => self.parse_rule_2186(skip_current_node), + 2187i64 => self.parse_rule_2187(skip_current_node), + 2188i64 => self.parse_rule_2188(skip_current_node), + 2189i64 => self.parse_rule_2189(skip_current_node), + 2190i64 => self.parse_rule_2190(skip_current_node), + 2191i64 => self.parse_rule_2191(skip_current_node), + 2192i64 => self.parse_rule_2192(skip_current_node), + 2193i64 => self.parse_rule_2193(skip_current_node), + 2194i64 => self.parse_rule_2194(skip_current_node), + 2195i64 => self.parse_rule_2195(skip_current_node), + 2196i64 => self.parse_rule_2196(skip_current_node), + 2197i64 => self.parse_rule_2197(skip_current_node), + 2198i64 => self.parse_rule_2198(skip_current_node), + 2199i64 => self.parse_rule_2199(skip_current_node), + 2200i64 => self.parse_rule_2200(skip_current_node), + 2201i64 => self.parse_rule_2201(skip_current_node), + 2202i64 => self.parse_rule_2202(skip_current_node), + 2203i64 => self.parse_rule_2203(skip_current_node), + 2204i64 => self.parse_rule_2204(skip_current_node), + 2205i64 => self.parse_rule_2205(skip_current_node), + 2206i64 => self.parse_rule_2206(skip_current_node), + 2207i64 => self.parse_rule_2207(skip_current_node), + 2208i64 => self.parse_rule_2208(skip_current_node), + 2209i64 => self.parse_rule_2209(skip_current_node), + 2210i64 => self.parse_rule_2210(skip_current_node), + 2211i64 => self.parse_rule_2211(skip_current_node), + 2212i64 => self.parse_rule_2212(skip_current_node), + 2213i64 => self.parse_rule_2213(skip_current_node), + 2214i64 => self.parse_rule_2214(skip_current_node), + 2215i64 => self.parse_rule_2215(skip_current_node), + 2216i64 => self.parse_rule_2216(skip_current_node), + 2217i64 => self.parse_rule_2217(skip_current_node), + 2218i64 => self.parse_rule_2218(skip_current_node), + 2219i64 => self.parse_rule_2219(skip_current_node), + 2220i64 => self.parse_rule_2220(skip_current_node), + 2221i64 => self.parse_rule_2221(skip_current_node), + 2222i64 => self.parse_rule_2222(skip_current_node), + 2223i64 => self.parse_rule_2223(skip_current_node), + 2224i64 => self.parse_rule_2224(skip_current_node), + 2225i64 => self.parse_rule_2225(skip_current_node), + 2226i64 => self.parse_rule_2226(skip_current_node), + 2227i64 => self.parse_rule_2227(skip_current_node), + 2228i64 => self.parse_rule_2228(skip_current_node), + 2229i64 => self.parse_rule_2229(skip_current_node), + 2230i64 => self.parse_rule_2230(skip_current_node), + 2231i64 => self.parse_rule_2231(skip_current_node), + 2232i64 => self.parse_rule_2232(skip_current_node), + 2233i64 => self.parse_rule_2233(skip_current_node), + 2234i64 => self.parse_rule_2234(skip_current_node), + 2235i64 => self.parse_rule_2235(skip_current_node), + 2236i64 => self.parse_rule_2236(skip_current_node), + 2237i64 => self.parse_rule_2237(skip_current_node), + 2238i64 => self.parse_rule_2238(skip_current_node), + 2239i64 => self.parse_rule_2239(skip_current_node), + 2240i64 => self.parse_rule_2240(skip_current_node), + 2241i64 => self.parse_rule_2241(skip_current_node), + 2242i64 => self.parse_rule_2242(skip_current_node), + 2243i64 => self.parse_rule_2243(skip_current_node), + 2244i64 => self.parse_rule_2244(skip_current_node), + 2245i64 => self.parse_rule_2245(skip_current_node), + 2246i64 => self.parse_rule_2246(skip_current_node), + 2247i64 => self.parse_rule_2247(skip_current_node), + 2248i64 => self.parse_rule_2248(skip_current_node), + 2249i64 => self.parse_rule_2249(skip_current_node), + 2250i64 => self.parse_rule_2250(skip_current_node), + 2251i64 => self.parse_rule_2251(skip_current_node), + 2252i64 => self.parse_rule_2252(skip_current_node), + 2253i64 => self.parse_rule_2253(skip_current_node), + 2254i64 => self.parse_rule_2254(skip_current_node), + 2255i64 => self.parse_rule_2255(skip_current_node), + 2256i64 => self.parse_rule_2256(skip_current_node), + 2257i64 => self.parse_rule_2257(skip_current_node), + 2258i64 => self.parse_rule_2258(skip_current_node), + 2259i64 => self.parse_rule_2259(skip_current_node), + 2260i64 => self.parse_rule_2260(skip_current_node), + 2261i64 => self.parse_rule_2261(skip_current_node), + 2262i64 => self.parse_rule_2262(skip_current_node), + 2263i64 => self.parse_rule_2263(skip_current_node), + 2264i64 => self.parse_rule_2264(skip_current_node), + 2265i64 => self.parse_rule_2265(skip_current_node), + 2266i64 => self.parse_rule_2266(skip_current_node), + 2267i64 => self.parse_rule_2267(skip_current_node), + 2268i64 => self.parse_rule_2268(skip_current_node), + 2269i64 => self.parse_rule_2269(skip_current_node), + 2270i64 => self.parse_rule_2270(skip_current_node), + 2271i64 => self.parse_rule_2271(skip_current_node), + 2272i64 => self.parse_rule_2272(skip_current_node), + 2273i64 => self.parse_rule_2273(skip_current_node), + 2274i64 => self.parse_rule_2274(skip_current_node), + 2275i64 => self.parse_rule_2275(skip_current_node), + 2276i64 => self.parse_rule_2276(skip_current_node), + 2277i64 => self.parse_rule_2277(skip_current_node), + 2278i64 => self.parse_rule_2278(skip_current_node), + 2279i64 => self.parse_rule_2279(skip_current_node), + 2280i64 => self.parse_rule_2280(skip_current_node), + 2281i64 => self.parse_rule_2281(skip_current_node), + 2282i64 => self.parse_rule_2282(skip_current_node), + 2283i64 => self.parse_rule_2283(skip_current_node), + 2284i64 => self.parse_rule_2284(skip_current_node), + 2285i64 => self.parse_rule_2285(skip_current_node), + 2286i64 => self.parse_rule_2286(skip_current_node), + 2287i64 => self.parse_rule_2287(skip_current_node), + 2288i64 => self.parse_rule_2288(skip_current_node), + 2289i64 => self.parse_rule_2289(skip_current_node), + 2290i64 => self.parse_rule_2290(skip_current_node), + 2291i64 => self.parse_rule_2291(skip_current_node), + 2292i64 => self.parse_rule_2292(skip_current_node), + 2293i64 => self.parse_rule_2293(skip_current_node), + 2294i64 => self.parse_rule_2294(skip_current_node), + 2295i64 => self.parse_rule_2295(skip_current_node), + 2296i64 => self.parse_rule_2296(skip_current_node), + 2297i64 => self.parse_rule_2297(skip_current_node), + 2298i64 => self.parse_rule_2298(skip_current_node), + 2299i64 => self.parse_rule_2299(skip_current_node), + 2300i64 => self.parse_rule_2300(skip_current_node), + 2301i64 => self.parse_rule_2301(skip_current_node), + 2302i64 => self.parse_rule_2302(skip_current_node), + 2303i64 => self.parse_rule_2303(skip_current_node), + 2304i64 => self.parse_rule_2304(skip_current_node), + 2305i64 => self.parse_rule_2305(skip_current_node), + 2306i64 => self.parse_rule_2306(skip_current_node), + 2307i64 => self.parse_rule_2307(skip_current_node), + 2308i64 => self.parse_rule_2308(skip_current_node), + 2309i64 => self.parse_rule_2309(skip_current_node), + 2310i64 => self.parse_rule_2310(skip_current_node), + 2311i64 => self.parse_rule_2311(skip_current_node), + 2312i64 => self.parse_rule_2312(skip_current_node), + 2313i64 => self.parse_rule_2313(skip_current_node), + 2314i64 => self.parse_rule_2314(skip_current_node), + 2315i64 => self.parse_rule_2315(skip_current_node), + 2316i64 => self.parse_rule_2316(skip_current_node), + 2317i64 => self.parse_rule_2317(skip_current_node), + 2318i64 => self.parse_rule_2318(skip_current_node), + 2319i64 => self.parse_rule_2319(skip_current_node), + 2320i64 => self.parse_rule_2320(skip_current_node), + 2321i64 => self.parse_rule_2321(skip_current_node), + 2322i64 => self.parse_rule_2322(skip_current_node), + 2323i64 => self.parse_rule_2323(skip_current_node), + 2324i64 => self.parse_rule_2324(skip_current_node), + 2325i64 => self.parse_rule_2325(skip_current_node), + 2326i64 => self.parse_rule_2326(skip_current_node), + 2327i64 => self.parse_rule_2327(skip_current_node), + 2328i64 => self.parse_rule_2328(skip_current_node), + 2329i64 => self.parse_rule_2329(skip_current_node), + 2330i64 => self.parse_rule_2330(skip_current_node), + 2331i64 => self.parse_rule_2331(skip_current_node), + 2332i64 => self.parse_rule_2332(skip_current_node), + 2333i64 => self.parse_rule_2333(skip_current_node), + 2334i64 => self.parse_rule_2334(skip_current_node), + 2335i64 => self.parse_rule_2335(skip_current_node), + 2336i64 => self.parse_rule_2336(skip_current_node), + 2337i64 => self.parse_rule_2337(skip_current_node), + 2338i64 => self.parse_rule_2338(skip_current_node), + 2339i64 => self.parse_rule_2339(skip_current_node), + 2340i64 => self.parse_rule_2340(skip_current_node), + 2341i64 => self.parse_rule_2341(skip_current_node), + 2342i64 => self.parse_rule_2342(skip_current_node), + 2343i64 => self.parse_rule_2343(skip_current_node), + 2344i64 => self.parse_rule_2344(skip_current_node), + 2345i64 => self.parse_rule_2345(skip_current_node), + 2346i64 => self.parse_rule_2346(skip_current_node), + 2347i64 => self.parse_rule_2347(skip_current_node), + 2348i64 => self.parse_rule_2348(skip_current_node), + 2349i64 => self.parse_rule_2349(skip_current_node), + 2350i64 => self.parse_rule_2350(skip_current_node), + 2351i64 => self.parse_rule_2351(skip_current_node), + 2352i64 => self.parse_rule_2352(skip_current_node), + 2353i64 => self.parse_rule_2353(skip_current_node), + 2354i64 => self.parse_rule_2354(skip_current_node), + 2355i64 => self.parse_rule_2355(skip_current_node), + 2356i64 => self.parse_rule_2356(skip_current_node), + 2357i64 => self.parse_rule_2357(skip_current_node), + 2358i64 => self.parse_rule_2358(skip_current_node), + 2359i64 => self.parse_rule_2359(skip_current_node), + 2360i64 => self.parse_rule_2360(skip_current_node), + 2361i64 => self.parse_rule_2361(skip_current_node), + 2362i64 => self.parse_rule_2362(skip_current_node), + 2363i64 => self.parse_rule_2363(skip_current_node), + 2364i64 => self.parse_rule_2364(skip_current_node), + 2365i64 => self.parse_rule_2365(skip_current_node), + 2366i64 => self.parse_rule_2366(skip_current_node), + 2367i64 => self.parse_rule_2367(skip_current_node), + 2368i64 => self.parse_rule_2368(skip_current_node), + 2369i64 => self.parse_rule_2369(skip_current_node), + 2370i64 => self.parse_rule_2370(skip_current_node), + 2371i64 => self.parse_rule_2371(skip_current_node), + 2372i64 => self.parse_rule_2372(skip_current_node), + 2373i64 => self.parse_rule_2373(skip_current_node), + 2374i64 => self.parse_rule_2374(skip_current_node), + 2375i64 => self.parse_rule_2375(skip_current_node), + 2376i64 => self.parse_rule_2376(skip_current_node), + 2377i64 => self.parse_rule_2377(skip_current_node), + 2378i64 => self.parse_rule_2378(skip_current_node), + 2379i64 => self.parse_rule_2379(skip_current_node), + 2380i64 => self.parse_rule_2380(skip_current_node), + 2381i64 => self.parse_rule_2381(skip_current_node), + 2382i64 => self.parse_rule_2382(skip_current_node), + 2383i64 => self.parse_rule_2383(skip_current_node), + 2384i64 => self.parse_rule_2384(skip_current_node), + 2385i64 => self.parse_rule_2385(skip_current_node), + 2386i64 => self.parse_rule_2386(skip_current_node), + 2387i64 => self.parse_rule_2387(skip_current_node), + 2388i64 => self.parse_rule_2388(skip_current_node), + 2389i64 => self.parse_rule_2389(skip_current_node), + 2390i64 => self.parse_rule_2390(skip_current_node), + 2391i64 => self.parse_rule_2391(skip_current_node), + 2392i64 => self.parse_rule_2392(skip_current_node), + 2393i64 => self.parse_rule_2393(skip_current_node), + 2394i64 => self.parse_rule_2394(skip_current_node), + 2395i64 => self.parse_rule_2395(skip_current_node), + 2396i64 => self.parse_rule_2396(skip_current_node), + 2397i64 => self.parse_rule_2397(skip_current_node), + 2398i64 => self.parse_rule_2398(skip_current_node), + 2399i64 => self.parse_rule_2399(skip_current_node), + 2400i64 => self.parse_rule_2400(skip_current_node), + 2401i64 => self.parse_rule_2401(skip_current_node), + 2402i64 => self.parse_rule_2402(skip_current_node), + 2403i64 => self.parse_rule_2403(skip_current_node), + 2404i64 => self.parse_rule_2404(skip_current_node), + 2405i64 => self.parse_rule_2405(skip_current_node), + 2406i64 => self.parse_rule_2406(skip_current_node), + 2407i64 => self.parse_rule_2407(skip_current_node), + 2408i64 => self.parse_rule_2408(skip_current_node), + 2409i64 => self.parse_rule_2409(skip_current_node), + 2410i64 => self.parse_rule_2410(skip_current_node), + 2411i64 => self.parse_rule_2411(skip_current_node), + 2412i64 => self.parse_rule_2412(skip_current_node), + 2413i64 => self.parse_rule_2413(skip_current_node), + 2414i64 => self.parse_rule_2414(skip_current_node), + 2415i64 => self.parse_rule_2415(skip_current_node), + 2416i64 => self.parse_rule_2416(skip_current_node), + 2417i64 => self.parse_rule_2417(skip_current_node), + 2418i64 => self.parse_rule_2418(skip_current_node), + 2419i64 => self.parse_rule_2419(skip_current_node), + 2420i64 => self.parse_rule_2420(skip_current_node), + 2421i64 => self.parse_rule_2421(skip_current_node), + 2422i64 => self.parse_rule_2422(skip_current_node), + 2423i64 => self.parse_rule_2423(skip_current_node), + 2424i64 => self.parse_rule_2424(skip_current_node), + 2425i64 => self.parse_rule_2425(skip_current_node), + 2426i64 => self.parse_rule_2426(skip_current_node), + 2427i64 => self.parse_rule_2427(skip_current_node), + 2428i64 => self.parse_rule_2428(skip_current_node), + 2429i64 => self.parse_rule_2429(skip_current_node), + 2430i64 => self.parse_rule_2430(skip_current_node), + 2431i64 => self.parse_rule_2431(skip_current_node), + 2432i64 => self.parse_rule_2432(skip_current_node), + 2433i64 => self.parse_rule_2433(skip_current_node), + 2434i64 => self.parse_rule_2434(skip_current_node), + 2435i64 => self.parse_rule_2435(skip_current_node), + 2436i64 => self.parse_rule_2436(skip_current_node), + 2437i64 => self.parse_rule_2437(skip_current_node), + 2438i64 => self.parse_rule_2438(skip_current_node), + 2439i64 => self.parse_rule_2439(skip_current_node), + 2440i64 => self.parse_rule_2440(skip_current_node), + 2441i64 => self.parse_rule_2441(skip_current_node), + 2442i64 => self.parse_rule_2442(skip_current_node), + 2443i64 => self.parse_rule_2443(skip_current_node), + 2444i64 => self.parse_rule_2444(skip_current_node), + 2445i64 => self.parse_rule_2445(skip_current_node), + 2446i64 => self.parse_rule_2446(skip_current_node), + 2447i64 => self.parse_rule_2447(skip_current_node), + 2448i64 => self.parse_rule_2448(skip_current_node), + 2449i64 => self.parse_rule_2449(skip_current_node), + 2450i64 => self.parse_rule_2450(skip_current_node), + 2451i64 => self.parse_rule_2451(skip_current_node), + 2452i64 => self.parse_rule_2452(skip_current_node), + 2453i64 => self.parse_rule_2453(skip_current_node), + 2454i64 => self.parse_rule_2454(skip_current_node), + 2455i64 => self.parse_rule_2455(skip_current_node), + 2456i64 => self.parse_rule_2456(skip_current_node), + 2457i64 => self.parse_rule_2457(skip_current_node), + 2458i64 => self.parse_rule_2458(skip_current_node), + 2459i64 => self.parse_rule_2459(skip_current_node), + 2460i64 => self.parse_rule_2460(skip_current_node), + 2461i64 => self.parse_rule_2461(skip_current_node), + 2462i64 => self.parse_rule_2462(skip_current_node), + 2463i64 => self.parse_rule_2463(skip_current_node), + 2464i64 => self.parse_rule_2464(skip_current_node), + 2465i64 => self.parse_rule_2465(skip_current_node), + 2466i64 => self.parse_rule_2466(skip_current_node), + 2467i64 => self.parse_rule_2467(skip_current_node), + 2468i64 => self.parse_rule_2468(skip_current_node), + 2469i64 => self.parse_rule_2469(skip_current_node), + 2470i64 => self.parse_rule_2470(skip_current_node), + 2471i64 => self.parse_rule_2471(skip_current_node), + 2472i64 => self.parse_rule_2472(skip_current_node), + 2473i64 => self.parse_rule_2473(skip_current_node), + 2474i64 => self.parse_rule_2474(skip_current_node), + 2475i64 => self.parse_rule_2475(skip_current_node), + 2476i64 => self.parse_rule_2476(skip_current_node), + 2477i64 => self.parse_rule_2477(skip_current_node), + 2478i64 => self.parse_rule_2478(skip_current_node), + 2479i64 => self.parse_rule_2479(skip_current_node), + 2480i64 => self.parse_rule_2480(skip_current_node), + 2481i64 => self.parse_rule_2481(skip_current_node), + 2482i64 => self.parse_rule_2482(skip_current_node), + 2483i64 => self.parse_rule_2483(skip_current_node), + 2484i64 => self.parse_rule_2484(skip_current_node), + 2485i64 => self.parse_rule_2485(skip_current_node), + 2486i64 => self.parse_rule_2486(skip_current_node), + 2487i64 => self.parse_rule_2487(skip_current_node), + 2488i64 => self.parse_rule_2488(skip_current_node), + 2489i64 => self.parse_rule_2489(skip_current_node), + 2490i64 => self.parse_rule_2490(skip_current_node), + 2491i64 => self.parse_rule_2491(skip_current_node), + 2492i64 => self.parse_rule_2492(skip_current_node), + 2493i64 => self.parse_rule_2493(skip_current_node), + 2494i64 => self.parse_rule_2494(skip_current_node), + 2495i64 => self.parse_rule_2495(skip_current_node), + 2496i64 => self.parse_rule_2496(skip_current_node), + 2497i64 => self.parse_rule_2497(skip_current_node), + 2498i64 => self.parse_rule_2498(skip_current_node), + 2499i64 => self.parse_rule_2499(skip_current_node), + 2500i64 => self.parse_rule_2500(skip_current_node), + 2501i64 => self.parse_rule_2501(skip_current_node), + 2502i64 => self.parse_rule_2502(skip_current_node), + 2503i64 => self.parse_rule_2503(skip_current_node), + 2504i64 => self.parse_rule_2504(skip_current_node), + 2505i64 => self.parse_rule_2505(skip_current_node), + 2506i64 => self.parse_rule_2506(skip_current_node), + 2507i64 => self.parse_rule_2507(skip_current_node), + 2508i64 => self.parse_rule_2508(skip_current_node), + 2509i64 => self.parse_rule_2509(skip_current_node), + 2510i64 => self.parse_rule_2510(skip_current_node), + 2511i64 => self.parse_rule_2511(skip_current_node), + 2512i64 => self.parse_rule_2512(skip_current_node), + 2513i64 => self.parse_rule_2513(skip_current_node), + 2514i64 => self.parse_rule_2514(skip_current_node), + 2515i64 => self.parse_rule_2515(skip_current_node), + 2516i64 => self.parse_rule_2516(skip_current_node), + 2517i64 => self.parse_rule_2517(skip_current_node), + 2518i64 => self.parse_rule_2518(skip_current_node), + 2519i64 => self.parse_rule_2519(skip_current_node), + 2520i64 => self.parse_rule_2520(skip_current_node), + 2521i64 => self.parse_rule_2521(skip_current_node), + 2522i64 => self.parse_rule_2522(skip_current_node), + 2523i64 => self.parse_rule_2523(skip_current_node), + 2524i64 => self.parse_rule_2524(skip_current_node), + 2525i64 => self.parse_rule_2525(skip_current_node), + 2526i64 => self.parse_rule_2526(skip_current_node), + 2527i64 => self.parse_rule_2527(skip_current_node), + 2528i64 => self.parse_rule_2528(skip_current_node), + 2529i64 => self.parse_rule_2529(skip_current_node), + 2530i64 => self.parse_rule_2530(skip_current_node), + 2531i64 => self.parse_rule_2531(skip_current_node), + 2532i64 => self.parse_rule_2532(skip_current_node), + 2533i64 => self.parse_rule_2533(skip_current_node), + 2534i64 => self.parse_rule_2534(skip_current_node), + 2535i64 => self.parse_rule_2535(skip_current_node), + 2536i64 => self.parse_rule_2536(skip_current_node), + 2537i64 => self.parse_rule_2537(skip_current_node), + 2538i64 => self.parse_rule_2538(skip_current_node), + 2539i64 => self.parse_rule_2539(skip_current_node), + 2540i64 => self.parse_rule_2540(skip_current_node), + 2541i64 => self.parse_rule_2541(skip_current_node), + 2542i64 => self.parse_rule_2542(skip_current_node), + 2543i64 => self.parse_rule_2543(skip_current_node), + 2544i64 => self.parse_rule_2544(skip_current_node), + 2545i64 => self.parse_rule_2545(skip_current_node), + 2546i64 => self.parse_rule_2546(skip_current_node), + 2547i64 => self.parse_rule_2547(skip_current_node), + 2548i64 => self.parse_rule_2548(skip_current_node), + 2549i64 => self.parse_rule_2549(skip_current_node), + 2550i64 => self.parse_rule_2550(skip_current_node), + 2551i64 => self.parse_rule_2551(skip_current_node), + 2552i64 => self.parse_rule_2552(skip_current_node), + 2553i64 => self.parse_rule_2553(skip_current_node), + 2554i64 => self.parse_rule_2554(skip_current_node), + 2555i64 => self.parse_rule_2555(skip_current_node), + 2556i64 => self.parse_rule_2556(skip_current_node), + 2557i64 => self.parse_rule_2557(skip_current_node), + 2558i64 => self.parse_rule_2558(skip_current_node), + 2559i64 => self.parse_rule_2559(skip_current_node), + 2560i64 => self.parse_rule_2560(skip_current_node), + 2561i64 => self.parse_rule_2561(skip_current_node), + 2562i64 => self.parse_rule_2562(skip_current_node), + 2563i64 => self.parse_rule_2563(skip_current_node), + 2564i64 => self.parse_rule_2564(skip_current_node), + 2565i64 => self.parse_rule_2565(skip_current_node), + 2566i64 => self.parse_rule_2566(skip_current_node), + 2567i64 => self.parse_rule_2567(skip_current_node), + 2568i64 => self.parse_rule_2568(skip_current_node), + 2569i64 => self.parse_rule_2569(skip_current_node), + 2570i64 => self.parse_rule_2570(skip_current_node), + 2571i64 => self.parse_rule_2571(skip_current_node), + 2572i64 => self.parse_rule_2572(skip_current_node), + 2573i64 => self.parse_rule_2573(skip_current_node), + 2574i64 => self.parse_rule_2574(skip_current_node), + 2575i64 => self.parse_rule_2575(skip_current_node), + 2576i64 => self.parse_rule_2576(skip_current_node), + 2577i64 => self.parse_rule_2577(skip_current_node), + 2578i64 => self.parse_rule_2578(skip_current_node), + 2579i64 => self.parse_rule_2579(skip_current_node), + 2580i64 => self.parse_rule_2580(skip_current_node), + 2581i64 => self.parse_rule_2581(skip_current_node), + 2582i64 => self.parse_rule_2582(skip_current_node), + 2583i64 => self.parse_rule_2583(skip_current_node), + 2584i64 => self.parse_rule_2584(skip_current_node), + 2585i64 => self.parse_rule_2585(skip_current_node), + 2586i64 => self.parse_rule_2586(skip_current_node), + 2587i64 => self.parse_rule_2587(skip_current_node), + 2588i64 => self.parse_rule_2588(skip_current_node), + 2589i64 => self.parse_rule_2589(skip_current_node), + 2590i64 => self.parse_rule_2590(skip_current_node), + 2591i64 => self.parse_rule_2591(skip_current_node), + 2592i64 => self.parse_rule_2592(skip_current_node), + 2593i64 => self.parse_rule_2593(skip_current_node), + 2594i64 => self.parse_rule_2594(skip_current_node), + 2595i64 => self.parse_rule_2595(skip_current_node), + 2596i64 => self.parse_rule_2596(skip_current_node), + 2597i64 => self.parse_rule_2597(skip_current_node), + 2598i64 => self.parse_rule_2598(skip_current_node), + 2599i64 => self.parse_rule_2599(skip_current_node), + 2600i64 => self.parse_rule_2600(skip_current_node), + 2601i64 => self.parse_rule_2601(skip_current_node), + 2602i64 => self.parse_rule_2602(skip_current_node), + 2603i64 => self.parse_rule_2603(skip_current_node), + 2604i64 => self.parse_rule_2604(skip_current_node), + 2605i64 => self.parse_rule_2605(skip_current_node), + 2606i64 => self.parse_rule_2606(skip_current_node), + 2607i64 => self.parse_rule_2607(skip_current_node), + 2608i64 => self.parse_rule_2608(skip_current_node), + 2609i64 => self.parse_rule_2609(skip_current_node), + 2610i64 => self.parse_rule_2610(skip_current_node), + 2611i64 => self.parse_rule_2611(skip_current_node), + 2612i64 => self.parse_rule_2612(skip_current_node), + 2613i64 => self.parse_rule_2613(skip_current_node), + 2614i64 => self.parse_rule_2614(skip_current_node), + 2615i64 => self.parse_rule_2615(skip_current_node), + 2616i64 => self.parse_rule_2616(skip_current_node), + 2617i64 => self.parse_rule_2617(skip_current_node), + 2618i64 => self.parse_rule_2618(skip_current_node), + 2619i64 => self.parse_rule_2619(skip_current_node), + 2620i64 => self.parse_rule_2620(skip_current_node), + 2621i64 => self.parse_rule_2621(skip_current_node), + 2622i64 => self.parse_rule_2622(skip_current_node), + 2623i64 => self.parse_rule_2623(skip_current_node), + 2624i64 => self.parse_rule_2624(skip_current_node), + 2625i64 => self.parse_rule_2625(skip_current_node), + 2626i64 => self.parse_rule_2626(skip_current_node), + 2627i64 => self.parse_rule_2627(skip_current_node), + 2628i64 => self.parse_rule_2628(skip_current_node), + 2629i64 => self.parse_rule_2629(skip_current_node), + 2630i64 => self.parse_rule_2630(skip_current_node), + 2631i64 => self.parse_rule_2631(skip_current_node), + 2632i64 => self.parse_rule_2632(skip_current_node), + 2633i64 => self.parse_rule_2633(skip_current_node), + 2634i64 => self.parse_rule_2634(skip_current_node), + 2635i64 => self.parse_rule_2635(skip_current_node), + 2636i64 => self.parse_rule_2636(skip_current_node), + 2637i64 => self.parse_rule_2637(skip_current_node), + 2638i64 => self.parse_rule_2638(skip_current_node), + 2639i64 => self.parse_rule_2639(skip_current_node), + 2640i64 => self.parse_rule_2640(skip_current_node), + 2641i64 => self.parse_rule_2641(skip_current_node), + 2642i64 => self.parse_rule_2642(skip_current_node), + 2643i64 => self.parse_rule_2643(skip_current_node), + 2644i64 => self.parse_rule_2644(skip_current_node), + 2645i64 => self.parse_rule_2645(skip_current_node), + 2646i64 => self.parse_rule_2646(skip_current_node), + 2647i64 => self.parse_rule_2647(skip_current_node), + 2648i64 => self.parse_rule_2648(skip_current_node), + 2649i64 => self.parse_rule_2649(skip_current_node), + 2650i64 => self.parse_rule_2650(skip_current_node), + 2651i64 => self.parse_rule_2651(skip_current_node), + 2652i64 => self.parse_rule_2652(skip_current_node), + 2653i64 => self.parse_rule_2653(skip_current_node), + 2654i64 => self.parse_rule_2654(skip_current_node), + 2655i64 => self.parse_rule_2655(skip_current_node), + 2656i64 => self.parse_rule_2656(skip_current_node), + 2657i64 => self.parse_rule_2657(skip_current_node), + 2658i64 => self.parse_rule_2658(skip_current_node), + 2659i64 => self.parse_rule_2659(skip_current_node), + 2660i64 => self.parse_rule_2660(skip_current_node), + 2661i64 => self.parse_rule_2661(skip_current_node), + 2662i64 => self.parse_rule_2662(skip_current_node), + 2663i64 => self.parse_rule_2663(skip_current_node), + 2664i64 => self.parse_rule_2664(skip_current_node), + 2665i64 => self.parse_rule_2665(skip_current_node), + 2666i64 => self.parse_rule_2666(skip_current_node), + 2667i64 => self.parse_rule_2667(skip_current_node), + 2668i64 => self.parse_rule_2668(skip_current_node), + 2669i64 => self.parse_rule_2669(skip_current_node), + 2670i64 => self.parse_rule_2670(skip_current_node), + 2671i64 => self.parse_rule_2671(skip_current_node), + 2672i64 => self.parse_rule_2672(skip_current_node), + 2673i64 => self.parse_rule_2673(skip_current_node), + 2674i64 => self.parse_rule_2674(skip_current_node), + 2675i64 => self.parse_rule_2675(skip_current_node), + 2676i64 => self.parse_rule_2676(skip_current_node), + 2677i64 => self.parse_rule_2677(skip_current_node), + 2678i64 => self.parse_rule_2678(skip_current_node), + 2679i64 => self.parse_rule_2679(skip_current_node), + 2680i64 => self.parse_rule_2680(skip_current_node), + 2681i64 => self.parse_rule_2681(skip_current_node), + 2682i64 => self.parse_rule_2682(skip_current_node), + 2683i64 => self.parse_rule_2683(skip_current_node), + 2684i64 => self.parse_rule_2684(skip_current_node), + 2685i64 => self.parse_rule_2685(skip_current_node), + 2686i64 => self.parse_rule_2686(skip_current_node), + 2687i64 => self.parse_rule_2687(skip_current_node), + 2688i64 => self.parse_rule_2688(skip_current_node), + 2689i64 => self.parse_rule_2689(skip_current_node), + 2690i64 => self.parse_rule_2690(skip_current_node), + 2691i64 => self.parse_rule_2691(skip_current_node), + 2692i64 => self.parse_rule_2692(skip_current_node), + 2693i64 => self.parse_rule_2693(skip_current_node), + 2694i64 => self.parse_rule_2694(skip_current_node), + 2695i64 => self.parse_rule_2695(skip_current_node), + 2696i64 => self.parse_rule_2696(skip_current_node), + 2697i64 => self.parse_rule_2697(skip_current_node), + 2698i64 => self.parse_rule_2698(skip_current_node), + 2699i64 => self.parse_rule_2699(skip_current_node), + 2700i64 => self.parse_rule_2700(skip_current_node), + 2701i64 => self.parse_rule_2701(skip_current_node), + 2702i64 => self.parse_rule_2702(skip_current_node), + 2703i64 => self.parse_rule_2703(skip_current_node), + 2704i64 => self.parse_rule_2704(skip_current_node), + 2705i64 => self.parse_rule_2705(skip_current_node), + 2706i64 => self.parse_rule_2706(skip_current_node), + 2707i64 => self.parse_rule_2707(skip_current_node), + 2708i64 => self.parse_rule_2708(skip_current_node), + 2709i64 => self.parse_rule_2709(skip_current_node), + 2710i64 => self.parse_rule_2710(skip_current_node), + 2711i64 => self.parse_rule_2711(skip_current_node), + 2712i64 => self.parse_rule_2712(skip_current_node), + 2713i64 => self.parse_rule_2713(skip_current_node), + 2714i64 => self.parse_rule_2714(skip_current_node), + 2715i64 => self.parse_rule_2715(skip_current_node), + 2716i64 => self.parse_rule_2716(skip_current_node), + 2717i64 => self.parse_rule_2717(skip_current_node), + 2718i64 => self.parse_rule_2718(skip_current_node), + 2719i64 => self.parse_rule_2719(skip_current_node), + 2720i64 => self.parse_rule_2720(skip_current_node), + 2721i64 => self.parse_rule_2721(skip_current_node), + 2722i64 => self.parse_rule_2722(skip_current_node), + 2723i64 => self.parse_rule_2723(skip_current_node), + 2724i64 => self.parse_rule_2724(skip_current_node), + 2725i64 => self.parse_rule_2725(skip_current_node), + 2726i64 => self.parse_rule_2726(skip_current_node), + 2727i64 => self.parse_rule_2727(skip_current_node), + 2728i64 => self.parse_rule_2728(skip_current_node), + 2729i64 => self.parse_rule_2729(skip_current_node), + 2730i64 => self.parse_rule_2730(skip_current_node), + 2731i64 => self.parse_rule_2731(skip_current_node), + 2732i64 => self.parse_rule_2732(skip_current_node), + 2733i64 => self.parse_rule_2733(skip_current_node), + 2734i64 => self.parse_rule_2734(skip_current_node), + 2735i64 => self.parse_rule_2735(skip_current_node), + 2736i64 => self.parse_rule_2736(skip_current_node), + 2737i64 => self.parse_rule_2737(skip_current_node), + 2738i64 => self.parse_rule_2738(skip_current_node), + 2739i64 => self.parse_rule_2739(skip_current_node), + 2740i64 => self.parse_rule_2740(skip_current_node), + 2741i64 => self.parse_rule_2741(skip_current_node), + 2742i64 => self.parse_rule_2742(skip_current_node), + 2743i64 => self.parse_rule_2743(skip_current_node), + 2744i64 => self.parse_rule_2744(skip_current_node), + 2745i64 => self.parse_rule_2745(skip_current_node), + 2746i64 => self.parse_rule_2746(skip_current_node), + 2747i64 => self.parse_rule_2747(skip_current_node), + 2748i64 => self.parse_rule_2748(skip_current_node), + 2749i64 => self.parse_rule_2749(skip_current_node), + 2750i64 => self.parse_rule_2750(skip_current_node), + 2751i64 => self.parse_rule_2751(skip_current_node), + 2752i64 => self.parse_rule_2752(skip_current_node), + 2753i64 => self.parse_rule_2753(skip_current_node), + 2754i64 => self.parse_rule_2754(skip_current_node), + 2755i64 => self.parse_rule_2755(skip_current_node), + 2756i64 => self.parse_rule_2756(skip_current_node), + 2757i64 => self.parse_rule_2757(skip_current_node), + 2758i64 => self.parse_rule_2758(skip_current_node), + 2759i64 => self.parse_rule_2759(skip_current_node), + 2760i64 => self.parse_rule_2760(skip_current_node), + 2761i64 => self.parse_rule_2761(skip_current_node), + 2762i64 => self.parse_rule_2762(skip_current_node), + 2763i64 => self.parse_rule_2763(skip_current_node), + 2764i64 => self.parse_rule_2764(skip_current_node), + 2765i64 => self.parse_rule_2765(skip_current_node), + 2766i64 => self.parse_rule_2766(skip_current_node), + 2767i64 => self.parse_rule_2767(skip_current_node), + 2768i64 => self.parse_rule_2768(skip_current_node), + 2769i64 => self.parse_rule_2769(skip_current_node), + 2770i64 => self.parse_rule_2770(skip_current_node), + 2771i64 => self.parse_rule_2771(skip_current_node), + 2772i64 => self.parse_rule_2772(skip_current_node), + 2773i64 => self.parse_rule_2773(skip_current_node), + 2774i64 => self.parse_rule_2774(skip_current_node), + 2775i64 => self.parse_rule_2775(skip_current_node), + 2776i64 => self.parse_rule_2776(skip_current_node), + 2777i64 => self.parse_rule_2777(skip_current_node), + 2778i64 => self.parse_rule_2778(skip_current_node), + 2779i64 => self.parse_rule_2779(skip_current_node), + 2780i64 => self.parse_rule_2780(skip_current_node), + 2781i64 => self.parse_rule_2781(skip_current_node), + 2782i64 => self.parse_rule_2782(skip_current_node), + 2783i64 => self.parse_rule_2783(skip_current_node), + 2784i64 => self.parse_rule_2784(skip_current_node), + 2785i64 => self.parse_rule_2785(skip_current_node), + 2786i64 => self.parse_rule_2786(skip_current_node), + 2787i64 => self.parse_rule_2787(skip_current_node), + 2788i64 => self.parse_rule_2788(skip_current_node), + 2789i64 => self.parse_rule_2789(skip_current_node), + 2790i64 => self.parse_rule_2790(skip_current_node), + 2791i64 => self.parse_rule_2791(skip_current_node), + 2792i64 => self.parse_rule_2792(skip_current_node), + 2793i64 => self.parse_rule_2793(skip_current_node), + 2794i64 => self.parse_rule_2794(skip_current_node), + 2795i64 => self.parse_rule_2795(skip_current_node), + 2796i64 => self.parse_rule_2796(skip_current_node), + 2797i64 => self.parse_rule_2797(skip_current_node), + 2798i64 => self.parse_rule_2798(skip_current_node), + 2799i64 => self.parse_rule_2799(skip_current_node), + 2800i64 => self.parse_rule_2800(skip_current_node), + 2801i64 => self.parse_rule_2801(skip_current_node), + 2802i64 => self.parse_rule_2802(skip_current_node), + 2803i64 => self.parse_rule_2803(skip_current_node), + 2804i64 => self.parse_rule_2804(skip_current_node), + 2805i64 => self.parse_rule_2805(skip_current_node), + 2806i64 => self.parse_rule_2806(skip_current_node), + 2807i64 => self.parse_rule_2807(skip_current_node), + 2808i64 => self.parse_rule_2808(skip_current_node), + 2809i64 => self.parse_rule_2809(skip_current_node), + 2810i64 => self.parse_rule_2810(skip_current_node), + 2811i64 => self.parse_rule_2811(skip_current_node), + 2812i64 => self.parse_rule_2812(skip_current_node), + 2813i64 => self.parse_rule_2813(skip_current_node), + 2814i64 => self.parse_rule_2814(skip_current_node), + 2815i64 => self.parse_rule_2815(skip_current_node), + 2816i64 => self.parse_rule_2816(skip_current_node), + 2817i64 => self.parse_rule_2817(skip_current_node), + 2818i64 => self.parse_rule_2818(skip_current_node), + 2819i64 => self.parse_rule_2819(skip_current_node), + 2820i64 => self.parse_rule_2820(skip_current_node), + 2821i64 => self.parse_rule_2821(skip_current_node), + 2822i64 => self.parse_rule_2822(skip_current_node), + 2823i64 => self.parse_rule_2823(skip_current_node), + 2824i64 => self.parse_rule_2824(skip_current_node), + 2825i64 => self.parse_rule_2825(skip_current_node), + 2826i64 => self.parse_rule_2826(skip_current_node), + 2827i64 => self.parse_rule_2827(skip_current_node), + 2828i64 => self.parse_rule_2828(skip_current_node), + 2829i64 => self.parse_rule_2829(skip_current_node), + 2830i64 => self.parse_rule_2830(skip_current_node), + 2831i64 => self.parse_rule_2831(skip_current_node), + 2832i64 => self.parse_rule_2832(skip_current_node), + 2833i64 => self.parse_rule_2833(skip_current_node), + 2834i64 => self.parse_rule_2834(skip_current_node), + 2835i64 => self.parse_rule_2835(skip_current_node), + 2836i64 => self.parse_rule_2836(skip_current_node), + 2837i64 => self.parse_rule_2837(skip_current_node), + 2838i64 => self.parse_rule_2838(skip_current_node), + 2839i64 => self.parse_rule_2839(skip_current_node), + 2840i64 => self.parse_rule_2840(skip_current_node), + 2841i64 => self.parse_rule_2841(skip_current_node), + 2842i64 => self.parse_rule_2842(skip_current_node), + 2843i64 => self.parse_rule_2843(skip_current_node), + 2844i64 => self.parse_rule_2844(skip_current_node), + 2845i64 => self.parse_rule_2845(skip_current_node), + 2846i64 => self.parse_rule_2846(skip_current_node), + 2847i64 => self.parse_rule_2847(skip_current_node), + 2848i64 => self.parse_rule_2848(skip_current_node), + 2849i64 => self.parse_rule_2849(skip_current_node), + 2850i64 => self.parse_rule_2850(skip_current_node), + 2851i64 => self.parse_rule_2851(skip_current_node), + 2852i64 => self.parse_rule_2852(skip_current_node), + 2853i64 => self.parse_rule_2853(skip_current_node), + 2854i64 => self.parse_rule_2854(skip_current_node), + 2855i64 => self.parse_rule_2855(skip_current_node), + 2856i64 => self.parse_rule_2856(skip_current_node), + 2857i64 => self.parse_rule_2857(skip_current_node), + 2858i64 => self.parse_rule_2858(skip_current_node), + 2859i64 => self.parse_rule_2859(skip_current_node), + 2860i64 => self.parse_rule_2860(skip_current_node), + 2861i64 => self.parse_rule_2861(skip_current_node), + 2862i64 => self.parse_rule_2862(skip_current_node), + 2863i64 => self.parse_rule_2863(skip_current_node), + 2864i64 => self.parse_rule_2864(skip_current_node), + 2865i64 => self.parse_rule_2865(skip_current_node), + 2866i64 => self.parse_rule_2866(skip_current_node), + 2867i64 => self.parse_rule_2867(skip_current_node), + 2868i64 => self.parse_rule_2868(skip_current_node), + 2869i64 => self.parse_rule_2869(skip_current_node), + 2870i64 => self.parse_rule_2870(skip_current_node), + 2871i64 => self.parse_rule_2871(skip_current_node), + 2872i64 => self.parse_rule_2872(skip_current_node), + 2873i64 => self.parse_rule_2873(skip_current_node), + 2874i64 => self.parse_rule_2874(skip_current_node), + 2875i64 => self.parse_rule_2875(skip_current_node), + 2876i64 => self.parse_rule_2876(skip_current_node), + 2877i64 => self.parse_rule_2877(skip_current_node), + 2878i64 => self.parse_rule_2878(skip_current_node), + 2879i64 => self.parse_rule_2879(skip_current_node), + 2880i64 => self.parse_rule_2880(skip_current_node), + 2881i64 => self.parse_rule_2881(skip_current_node), + 2882i64 => self.parse_rule_2882(skip_current_node), + 2883i64 => self.parse_rule_2883(skip_current_node), + 2884i64 => self.parse_rule_2884(skip_current_node), + 2885i64 => self.parse_rule_2885(skip_current_node), + 2886i64 => self.parse_rule_2886(skip_current_node), + 2887i64 => self.parse_rule_2887(skip_current_node), + 2888i64 => self.parse_rule_2888(skip_current_node), + 2889i64 => self.parse_rule_2889(skip_current_node), + 2890i64 => self.parse_rule_2890(skip_current_node), + 2891i64 => self.parse_rule_2891(skip_current_node), + 2892i64 => self.parse_rule_2892(skip_current_node), + 2893i64 => self.parse_rule_2893(skip_current_node), + 2894i64 => self.parse_rule_2894(skip_current_node), + 2895i64 => self.parse_rule_2895(skip_current_node), + 2896i64 => self.parse_rule_2896(skip_current_node), + 2897i64 => self.parse_rule_2897(skip_current_node), + 2898i64 => self.parse_rule_2898(skip_current_node), + 2899i64 => self.parse_rule_2899(skip_current_node), + 2900i64 => self.parse_rule_2900(skip_current_node), + 2901i64 => self.parse_rule_2901(skip_current_node), + 2902i64 => self.parse_rule_2902(skip_current_node), + 2903i64 => self.parse_rule_2903(skip_current_node), + 2904i64 => self.parse_rule_2904(skip_current_node), + 2905i64 => self.parse_rule_2905(skip_current_node), + 2906i64 => self.parse_rule_2906(skip_current_node), + 2907i64 => self.parse_rule_2907(skip_current_node), + 2908i64 => self.parse_rule_2908(skip_current_node), + 2909i64 => self.parse_rule_2909(skip_current_node), + 2910i64 => self.parse_rule_2910(skip_current_node), + 2911i64 => self.parse_rule_2911(skip_current_node), + 2912i64 => self.parse_rule_2912(skip_current_node), + 2913i64 => self.parse_rule_2913(skip_current_node), + 2914i64 => self.parse_rule_2914(skip_current_node), + 2915i64 => self.parse_rule_2915(skip_current_node), + 2916i64 => self.parse_rule_2916(skip_current_node), + 2917i64 => self.parse_rule_2917(skip_current_node), + 2918i64 => self.parse_rule_2918(skip_current_node), + 2919i64 => self.parse_rule_2919(skip_current_node), + 2920i64 => self.parse_rule_2920(skip_current_node), + 2921i64 => self.parse_rule_2921(skip_current_node), + 2922i64 => self.parse_rule_2922(skip_current_node), + 2923i64 => self.parse_rule_2923(skip_current_node), + 2924i64 => self.parse_rule_2924(skip_current_node), + 2925i64 => self.parse_rule_2925(skip_current_node), + 2926i64 => self.parse_rule_2926(skip_current_node), + 2927i64 => self.parse_rule_2927(skip_current_node), + 2928i64 => self.parse_rule_2928(skip_current_node), + 2929i64 => self.parse_rule_2929(skip_current_node), + 2930i64 => self.parse_rule_2930(skip_current_node), + 2931i64 => self.parse_rule_2931(skip_current_node), + 2932i64 => self.parse_rule_2932(skip_current_node), + 2933i64 => self.parse_rule_2933(skip_current_node), + 2934i64 => self.parse_rule_2934(skip_current_node), + 2935i64 => self.parse_rule_2935(skip_current_node), + 2936i64 => self.parse_rule_2936(skip_current_node), + 2937i64 => self.parse_rule_2937(skip_current_node), + 2938i64 => self.parse_rule_2938(skip_current_node), + 2939i64 => self.parse_rule_2939(skip_current_node), + 2940i64 => self.parse_rule_2940(skip_current_node), + 2941i64 => self.parse_rule_2941(skip_current_node), + 2942i64 => self.parse_rule_2942(skip_current_node), + 2943i64 => self.parse_rule_2943(skip_current_node), + 2944i64 => self.parse_rule_2944(skip_current_node), + 2945i64 => self.parse_rule_2945(skip_current_node), + 2946i64 => self.parse_rule_2946(skip_current_node), + 2947i64 => self.parse_rule_2947(skip_current_node), + 2948i64 => self.parse_rule_2948(skip_current_node), + 2949i64 => self.parse_rule_2949(skip_current_node), + 2950i64 => self.parse_rule_2950(skip_current_node), + 2951i64 => self.parse_rule_2951(skip_current_node), + 2952i64 => self.parse_rule_2952(skip_current_node), + 2953i64 => self.parse_rule_2953(skip_current_node), + 2954i64 => self.parse_rule_2954(skip_current_node), + 2955i64 => self.parse_rule_2955(skip_current_node), + 2956i64 => self.parse_rule_2956(skip_current_node), + 2957i64 => self.parse_rule_2957(skip_current_node), + 2958i64 => self.parse_rule_2958(skip_current_node), + 2959i64 => self.parse_rule_2959(skip_current_node), + 2960i64 => self.parse_rule_2960(skip_current_node), + 2961i64 => self.parse_rule_2961(skip_current_node), + 2962i64 => self.parse_rule_2962(skip_current_node), + 2963i64 => self.parse_rule_2963(skip_current_node), + 2964i64 => self.parse_rule_2964(skip_current_node), + 2965i64 => self.parse_rule_2965(skip_current_node), + 2966i64 => self.parse_rule_2966(skip_current_node), + 2967i64 => self.parse_rule_2967(skip_current_node), + 2968i64 => self.parse_rule_2968(skip_current_node), + 2969i64 => self.parse_rule_2969(skip_current_node), + 2970i64 => self.parse_rule_2970(skip_current_node), + 2971i64 => self.parse_rule_2971(skip_current_node), + 2972i64 => self.parse_rule_2972(skip_current_node), + 2973i64 => self.parse_rule_2973(skip_current_node), + 2974i64 => self.parse_rule_2974(skip_current_node), + 2975i64 => self.parse_rule_2975(skip_current_node), + 2976i64 => self.parse_rule_2976(skip_current_node), + 2977i64 => self.parse_rule_2977(skip_current_node), + 2978i64 => self.parse_rule_2978(skip_current_node), + 2979i64 => self.parse_rule_2979(skip_current_node), + 2980i64 => self.parse_rule_2980(skip_current_node), + 2981i64 => self.parse_rule_2981(skip_current_node), + 2982i64 => self.parse_rule_2982(skip_current_node), + 2983i64 => self.parse_rule_2983(skip_current_node), + 2984i64 => self.parse_rule_2984(skip_current_node), + 2985i64 => self.parse_rule_2985(skip_current_node), + 2986i64 => self.parse_rule_2986(skip_current_node), + 2987i64 => self.parse_rule_2987(skip_current_node), + 2988i64 => self.parse_rule_2988(skip_current_node), + 2989i64 => self.parse_rule_2989(skip_current_node), + 2990i64 => self.parse_rule_2990(skip_current_node), + 2991i64 => self.parse_rule_2991(skip_current_node), + 2992i64 => self.parse_rule_2992(skip_current_node), + 2993i64 => self.parse_rule_2993(skip_current_node), + 2994i64 => self.parse_rule_2994(skip_current_node), + 2995i64 => self.parse_rule_2995(skip_current_node), + 2996i64 => self.parse_rule_2996(skip_current_node), + 2997i64 => self.parse_rule_2997(skip_current_node), + 2998i64 => self.parse_rule_2998(skip_current_node), + 2999i64 => self.parse_rule_2999(skip_current_node), + 3000i64 => self.parse_rule_3000(skip_current_node), + 3001i64 => self.parse_rule_3001(skip_current_node), + 3002i64 => self.parse_rule_3002(skip_current_node), + 3003i64 => self.parse_rule_3003(skip_current_node), + 3004i64 => self.parse_rule_3004(skip_current_node), + 3005i64 => self.parse_rule_3005(skip_current_node), + 3006i64 => self.parse_rule_3006(skip_current_node), + 3007i64 => self.parse_rule_3007(skip_current_node), + 3008i64 => self.parse_rule_3008(skip_current_node), + 3009i64 => self.parse_rule_3009(skip_current_node), + 3010i64 => self.parse_rule_3010(skip_current_node), + 3011i64 => self.parse_rule_3011(skip_current_node), + 3012i64 => self.parse_rule_3012(skip_current_node), + 3013i64 => self.parse_rule_3013(skip_current_node), + 3014i64 => self.parse_rule_3014(skip_current_node), + 3015i64 => self.parse_rule_3015(skip_current_node), + 3016i64 => self.parse_rule_3016(skip_current_node), + 3017i64 => self.parse_rule_3017(skip_current_node), + 3018i64 => self.parse_rule_3018(skip_current_node), + 3019i64 => self.parse_rule_3019(skip_current_node), + 3020i64 => self.parse_rule_3020(skip_current_node), + 3021i64 => self.parse_rule_3021(skip_current_node), + 3022i64 => self.parse_rule_3022(skip_current_node), + 3023i64 => self.parse_rule_3023(skip_current_node), + 3024i64 => self.parse_rule_3024(skip_current_node), + 3025i64 => self.parse_rule_3025(skip_current_node), + 3026i64 => self.parse_rule_3026(skip_current_node), + 3027i64 => self.parse_rule_3027(skip_current_node), + 3028i64 => self.parse_rule_3028(skip_current_node), + 3029i64 => self.parse_rule_3029(skip_current_node), + 3030i64 => self.parse_rule_3030(skip_current_node), + 3031i64 => self.parse_rule_3031(skip_current_node), + 3032i64 => self.parse_rule_3032(skip_current_node), + 3033i64 => self.parse_rule_3033(skip_current_node), + 3034i64 => self.parse_rule_3034(skip_current_node), + 3035i64 => self.parse_rule_3035(skip_current_node), + 3036i64 => self.parse_rule_3036(skip_current_node), + 3037i64 => self.parse_rule_3037(skip_current_node), + 3038i64 => self.parse_rule_3038(skip_current_node), + 3039i64 => self.parse_rule_3039(skip_current_node), + 3040i64 => self.parse_rule_3040(skip_current_node), + 3041i64 => self.parse_rule_3041(skip_current_node), + 3042i64 => self.parse_rule_3042(skip_current_node), + 3043i64 => self.parse_rule_3043(skip_current_node), + 3044i64 => self.parse_rule_3044(skip_current_node), + 3045i64 => self.parse_rule_3045(skip_current_node), + 3046i64 => self.parse_rule_3046(skip_current_node), + 3047i64 => self.parse_rule_3047(skip_current_node), + 3048i64 => self.parse_rule_3048(skip_current_node), + 3049i64 => self.parse_rule_3049(skip_current_node), + 3050i64 => self.parse_rule_3050(skip_current_node), + 3051i64 => self.parse_rule_3051(skip_current_node), + 3052i64 => self.parse_rule_3052(skip_current_node), + 3053i64 => self.parse_rule_3053(skip_current_node), + 3054i64 => self.parse_rule_3054(skip_current_node), + 3055i64 => self.parse_rule_3055(skip_current_node), + 3056i64 => self.parse_rule_3056(skip_current_node), + 3057i64 => self.parse_rule_3057(skip_current_node), + 3058i64 => self.parse_rule_3058(skip_current_node), + 3059i64 => self.parse_rule_3059(skip_current_node), + 3060i64 => self.parse_rule_3060(skip_current_node), + 3061i64 => self.parse_rule_3061(skip_current_node), + 3062i64 => self.parse_rule_3062(skip_current_node), + 3063i64 => self.parse_rule_3063(skip_current_node), + 3064i64 => self.parse_rule_3064(skip_current_node), + 3065i64 => self.parse_rule_3065(skip_current_node), + 3066i64 => self.parse_rule_3066(skip_current_node), + 3067i64 => self.parse_rule_3067(skip_current_node), + 3068i64 => self.parse_rule_3068(skip_current_node), + 3069i64 => self.parse_rule_3069(skip_current_node), + 3070i64 => self.parse_rule_3070(skip_current_node), + 3071i64 => self.parse_rule_3071(skip_current_node), + 3072i64 => self.parse_rule_3072(skip_current_node), + 3073i64 => self.parse_rule_3073(skip_current_node), + 3074i64 => self.parse_rule_3074(skip_current_node), + 3075i64 => self.parse_rule_3075(skip_current_node), + 3076i64 => self.parse_rule_3076(skip_current_node), + 3077i64 => self.parse_rule_3077(skip_current_node), + 3078i64 => self.parse_rule_3078(skip_current_node), + 3079i64 => self.parse_rule_3079(skip_current_node), + 3080i64 => self.parse_rule_3080(skip_current_node), + 3081i64 => self.parse_rule_3081(skip_current_node), + 3082i64 => self.parse_rule_3082(skip_current_node), + 3083i64 => self.parse_rule_3083(skip_current_node), + 3084i64 => self.parse_rule_3084(skip_current_node), + 3085i64 => self.parse_rule_3085(skip_current_node), + 3086i64 => self.parse_rule_3086(skip_current_node), + 3087i64 => self.parse_rule_3087(skip_current_node), + 3088i64 => self.parse_rule_3088(skip_current_node), + 3089i64 => self.parse_rule_3089(skip_current_node), + 3090i64 => self.parse_rule_3090(skip_current_node), + 3091i64 => self.parse_rule_3091(skip_current_node), + 3092i64 => self.parse_rule_3092(skip_current_node), + 3093i64 => self.parse_rule_3093(skip_current_node), + 3094i64 => self.parse_rule_3094(skip_current_node), + 3095i64 => self.parse_rule_3095(skip_current_node), + 3096i64 => self.parse_rule_3096(skip_current_node), + 3097i64 => self.parse_rule_3097(skip_current_node), + 3098i64 => self.parse_rule_3098(skip_current_node), + 3099i64 => self.parse_rule_3099(skip_current_node), + 3100i64 => self.parse_rule_3100(skip_current_node), + 3101i64 => self.parse_rule_3101(skip_current_node), + 3102i64 => self.parse_rule_3102(skip_current_node), + 3103i64 => self.parse_rule_3103(skip_current_node), + 3104i64 => self.parse_rule_3104(skip_current_node), + 3105i64 => self.parse_rule_3105(skip_current_node), + 3106i64 => self.parse_rule_3106(skip_current_node), + 3107i64 => self.parse_rule_3107(skip_current_node), + 3108i64 => self.parse_rule_3108(skip_current_node), + 3109i64 => self.parse_rule_3109(skip_current_node), + 3110i64 => self.parse_rule_3110(skip_current_node), + 3111i64 => self.parse_rule_3111(skip_current_node), + 3112i64 => self.parse_rule_3112(skip_current_node), + 3113i64 => self.parse_rule_3113(skip_current_node), + 3114i64 => self.parse_rule_3114(skip_current_node), + 3115i64 => self.parse_rule_3115(skip_current_node), + 3116i64 => self.parse_rule_3116(skip_current_node), + 3117i64 => self.parse_rule_3117(skip_current_node), + 3118i64 => self.parse_rule_3118(skip_current_node), + 3119i64 => self.parse_rule_3119(skip_current_node), + 3120i64 => self.parse_rule_3120(skip_current_node), + 3121i64 => self.parse_rule_3121(skip_current_node), + 3122i64 => self.parse_rule_3122(skip_current_node), + 3123i64 => self.parse_rule_3123(skip_current_node), + 3124i64 => self.parse_rule_3124(skip_current_node), + 3125i64 => self.parse_rule_3125(skip_current_node), + 3126i64 => self.parse_rule_3126(skip_current_node), + 3127i64 => self.parse_rule_3127(skip_current_node), + 3128i64 => self.parse_rule_3128(skip_current_node), + 3129i64 => self.parse_rule_3129(skip_current_node), + 3130i64 => self.parse_rule_3130(skip_current_node), + 3131i64 => self.parse_rule_3131(skip_current_node), + 3132i64 => self.parse_rule_3132(skip_current_node), + 3133i64 => self.parse_rule_3133(skip_current_node), + 3134i64 => self.parse_rule_3134(skip_current_node), + 3135i64 => self.parse_rule_3135(skip_current_node), + 3136i64 => self.parse_rule_3136(skip_current_node), + 3137i64 => self.parse_rule_3137(skip_current_node), + 3138i64 => self.parse_rule_3138(skip_current_node), + 3139i64 => self.parse_rule_3139(skip_current_node), + 3140i64 => self.parse_rule_3140(skip_current_node), + 3141i64 => self.parse_rule_3141(skip_current_node), + 3142i64 => self.parse_rule_3142(skip_current_node), + 3143i64 => self.parse_rule_3143(skip_current_node), + 3144i64 => self.parse_rule_3144(skip_current_node), + 3145i64 => self.parse_rule_3145(skip_current_node), + 3146i64 => self.parse_rule_3146(skip_current_node), + 3147i64 => self.parse_rule_3147(skip_current_node), + 3148i64 => self.parse_rule_3148(skip_current_node), + 3149i64 => self.parse_rule_3149(skip_current_node), + 3150i64 => self.parse_rule_3150(skip_current_node), + 3151i64 => self.parse_rule_3151(skip_current_node), + 3152i64 => self.parse_rule_3152(skip_current_node), + 3153i64 => self.parse_rule_3153(skip_current_node), + 3154i64 => self.parse_rule_3154(skip_current_node), + 3155i64 => self.parse_rule_3155(skip_current_node), + 3156i64 => self.parse_rule_3156(skip_current_node), + 3157i64 => self.parse_rule_3157(skip_current_node), + 3158i64 => self.parse_rule_3158(skip_current_node), + 3159i64 => self.parse_rule_3159(skip_current_node), + 3160i64 => self.parse_rule_3160(skip_current_node), + 3161i64 => self.parse_rule_3161(skip_current_node), + 3162i64 => self.parse_rule_3162(skip_current_node), + 3163i64 => self.parse_rule_3163(skip_current_node), + 3164i64 => self.parse_rule_3164(skip_current_node), + 3165i64 => self.parse_rule_3165(skip_current_node), + 3166i64 => self.parse_rule_3166(skip_current_node), + 3167i64 => self.parse_rule_3167(skip_current_node), + 3168i64 => self.parse_rule_3168(skip_current_node), + 3169i64 => self.parse_rule_3169(skip_current_node), + 3170i64 => self.parse_rule_3170(skip_current_node), + 3171i64 => self.parse_rule_3171(skip_current_node), + 3172i64 => self.parse_rule_3172(skip_current_node), + 3173i64 => self.parse_rule_3173(skip_current_node), + 3174i64 => self.parse_rule_3174(skip_current_node), + 3175i64 => self.parse_rule_3175(skip_current_node), + 3176i64 => self.parse_rule_3176(skip_current_node), + 3177i64 => self.parse_rule_3177(skip_current_node), + 3178i64 => self.parse_rule_3178(skip_current_node), + 3179i64 => self.parse_rule_3179(skip_current_node), + 3180i64 => self.parse_rule_3180(skip_current_node), + 3181i64 => self.parse_rule_3181(skip_current_node), + 3182i64 => self.parse_rule_3182(skip_current_node), + 3183i64 => self.parse_rule_3183(skip_current_node), + 3184i64 => self.parse_rule_3184(skip_current_node), + 3185i64 => self.parse_rule_3185(skip_current_node), + 3186i64 => self.parse_rule_3186(skip_current_node), + 3187i64 => self.parse_rule_3187(skip_current_node), + 3188i64 => self.parse_rule_3188(skip_current_node), + 3189i64 => self.parse_rule_3189(skip_current_node), + 3190i64 => self.parse_rule_3190(skip_current_node), + 3191i64 => self.parse_rule_3191(skip_current_node), + 3192i64 => self.parse_rule_3192(skip_current_node), + 3193i64 => self.parse_rule_3193(skip_current_node), + 3194i64 => self.parse_rule_3194(skip_current_node), + 3195i64 => self.parse_rule_3195(skip_current_node), + 3196i64 => self.parse_rule_3196(skip_current_node), + 3197i64 => self.parse_rule_3197(skip_current_node), + 3198i64 => self.parse_rule_3198(skip_current_node), + 3199i64 => self.parse_rule_3199(skip_current_node), + 3200i64 => self.parse_rule_3200(skip_current_node), + 3201i64 => self.parse_rule_3201(skip_current_node), + 3202i64 => self.parse_rule_3202(skip_current_node), + 3203i64 => self.parse_rule_3203(skip_current_node), + 3204i64 => self.parse_rule_3204(skip_current_node), + 3205i64 => self.parse_rule_3205(skip_current_node), + 3206i64 => self.parse_rule_3206(skip_current_node), + 3207i64 => self.parse_rule_3207(skip_current_node), + 3208i64 => self.parse_rule_3208(skip_current_node), + 3209i64 => self.parse_rule_3209(skip_current_node), + 3210i64 => self.parse_rule_3210(skip_current_node), + 3211i64 => self.parse_rule_3211(skip_current_node), + 3212i64 => self.parse_rule_3212(skip_current_node), + 3213i64 => self.parse_rule_3213(skip_current_node), + 3214i64 => self.parse_rule_3214(skip_current_node), + 3215i64 => self.parse_rule_3215(skip_current_node), + 3216i64 => self.parse_rule_3216(skip_current_node), + 3217i64 => self.parse_rule_3217(skip_current_node), + 3218i64 => self.parse_rule_3218(skip_current_node), + 3219i64 => self.parse_rule_3219(skip_current_node), + 3220i64 => self.parse_rule_3220(skip_current_node), + 3221i64 => self.parse_rule_3221(skip_current_node), + 3222i64 => self.parse_rule_3222(skip_current_node), + 3223i64 => self.parse_rule_3223(skip_current_node), + 3224i64 => self.parse_rule_3224(skip_current_node), + 3225i64 => self.parse_rule_3225(skip_current_node), + 3226i64 => self.parse_rule_3226(skip_current_node), + 3227i64 => self.parse_rule_3227(skip_current_node), + 3228i64 => self.parse_rule_3228(skip_current_node), + 3229i64 => self.parse_rule_3229(skip_current_node), + 3230i64 => self.parse_rule_3230(skip_current_node), + 3231i64 => self.parse_rule_3231(skip_current_node), + 3232i64 => self.parse_rule_3232(skip_current_node), + 3233i64 => self.parse_rule_3233(skip_current_node), + 3234i64 => self.parse_rule_3234(skip_current_node), + 3235i64 => self.parse_rule_3235(skip_current_node), + 3236i64 => self.parse_rule_3236(skip_current_node), + 3237i64 => self.parse_rule_3237(skip_current_node), + 3238i64 => self.parse_rule_3238(skip_current_node), + 3239i64 => self.parse_rule_3239(skip_current_node), + 3240i64 => self.parse_rule_3240(skip_current_node), + 3241i64 => self.parse_rule_3241(skip_current_node), + 3242i64 => self.parse_rule_3242(skip_current_node), + 3243i64 => self.parse_rule_3243(skip_current_node), + 3244i64 => self.parse_rule_3244(skip_current_node), + 3245i64 => self.parse_rule_3245(skip_current_node), + 3246i64 => self.parse_rule_3246(skip_current_node), + 3247i64 => self.parse_rule_3247(skip_current_node), + 3248i64 => self.parse_rule_3248(skip_current_node), + 3249i64 => self.parse_rule_3249(skip_current_node), + 3250i64 => self.parse_rule_3250(skip_current_node), + 3251i64 => self.parse_rule_3251(skip_current_node), + 3252i64 => self.parse_rule_3252(skip_current_node), + 3253i64 => self.parse_rule_3253(skip_current_node), + 3254i64 => self.parse_rule_3254(skip_current_node), + 3255i64 => self.parse_rule_3255(skip_current_node), + 3256i64 => self.parse_rule_3256(skip_current_node), + 3257i64 => self.parse_rule_3257(skip_current_node), + 3258i64 => self.parse_rule_3258(skip_current_node), + 3259i64 => self.parse_rule_3259(skip_current_node), + 3260i64 => self.parse_rule_3260(skip_current_node), + 3261i64 => self.parse_rule_3261(skip_current_node), + 3262i64 => self.parse_rule_3262(skip_current_node), + 3263i64 => self.parse_rule_3263(skip_current_node), + 3264i64 => self.parse_rule_3264(skip_current_node), + 3265i64 => self.parse_rule_3265(skip_current_node), + 3266i64 => self.parse_rule_3266(skip_current_node), + 3267i64 => self.parse_rule_3267(skip_current_node), + 3268i64 => self.parse_rule_3268(skip_current_node), + 3269i64 => self.parse_rule_3269(skip_current_node), + 3270i64 => self.parse_rule_3270(skip_current_node), + 3271i64 => self.parse_rule_3271(skip_current_node), + 3272i64 => self.parse_rule_3272(skip_current_node), + 3273i64 => self.parse_rule_3273(skip_current_node), + 3274i64 => self.parse_rule_3274(skip_current_node), + 3275i64 => self.parse_rule_3275(skip_current_node), + 3276i64 => self.parse_rule_3276(skip_current_node), + 3277i64 => self.parse_rule_3277(skip_current_node), + 3278i64 => self.parse_rule_3278(skip_current_node), + 3279i64 => self.parse_rule_3279(skip_current_node), + 3280i64 => self.parse_rule_3280(skip_current_node), + 3281i64 => self.parse_rule_3281(skip_current_node), + 3282i64 => self.parse_rule_3282(skip_current_node), + 3283i64 => self.parse_rule_3283(skip_current_node), + 3284i64 => self.parse_rule_3284(skip_current_node), + 3285i64 => self.parse_rule_3285(skip_current_node), + 3286i64 => self.parse_rule_3286(skip_current_node), + 3287i64 => self.parse_rule_3287(skip_current_node), + 3288i64 => self.parse_rule_3288(skip_current_node), + 3289i64 => self.parse_rule_3289(skip_current_node), + 3290i64 => self.parse_rule_3290(skip_current_node), + 3291i64 => self.parse_rule_3291(skip_current_node), + 3292i64 => self.parse_rule_3292(skip_current_node), + 3293i64 => self.parse_rule_3293(skip_current_node), + 3294i64 => self.parse_rule_3294(skip_current_node), + 3295i64 => self.parse_rule_3295(skip_current_node), + 3296i64 => self.parse_rule_3296(skip_current_node), + 3297i64 => self.parse_rule_3297(skip_current_node), + 3298i64 => self.parse_rule_3298(skip_current_node), + 3299i64 => self.parse_rule_3299(skip_current_node), + 3300i64 => self.parse_rule_3300(skip_current_node), + 3301i64 => self.parse_rule_3301(skip_current_node), + 3302i64 => self.parse_rule_3302(skip_current_node), + 3303i64 => self.parse_rule_3303(skip_current_node), + 3304i64 => self.parse_rule_3304(skip_current_node), + 3305i64 => self.parse_rule_3305(skip_current_node), + 3306i64 => self.parse_rule_3306(skip_current_node), + 3307i64 => self.parse_rule_3307(skip_current_node), + 3308i64 => self.parse_rule_3308(skip_current_node), + 3309i64 => self.parse_rule_3309(skip_current_node), + 3310i64 => self.parse_rule_3310(skip_current_node), + 3311i64 => self.parse_rule_3311(skip_current_node), + 3312i64 => self.parse_rule_3312(skip_current_node), + 3313i64 => self.parse_rule_3313(skip_current_node), + 3314i64 => self.parse_rule_3314(skip_current_node), + 3315i64 => self.parse_rule_3315(skip_current_node), + 3316i64 => self.parse_rule_3316(skip_current_node), + 3317i64 => self.parse_rule_3317(skip_current_node), + 3318i64 => self.parse_rule_3318(skip_current_node), + 3319i64 => self.parse_rule_3319(skip_current_node), + 3320i64 => self.parse_rule_3320(skip_current_node), + 3321i64 => self.parse_rule_3321(skip_current_node), + 3322i64 => self.parse_rule_3322(skip_current_node), + 3323i64 => self.parse_rule_3323(skip_current_node), + 3324i64 => self.parse_rule_3324(skip_current_node), + 3325i64 => self.parse_rule_3325(skip_current_node), + 3326i64 => self.parse_rule_3326(skip_current_node), + 3327i64 => self.parse_rule_3327(skip_current_node), + 3328i64 => self.parse_rule_3328(skip_current_node), + 3329i64 => self.parse_rule_3329(skip_current_node), + 3330i64 => self.parse_rule_3330(skip_current_node), + 3331i64 => self.parse_rule_3331(skip_current_node), + 3332i64 => self.parse_rule_3332(skip_current_node), + 3333i64 => self.parse_rule_3333(skip_current_node), + 3334i64 => self.parse_rule_3334(skip_current_node), + 3335i64 => self.parse_rule_3335(skip_current_node), + 3336i64 => self.parse_rule_3336(skip_current_node), + 3337i64 => self.parse_rule_3337(skip_current_node), + 3338i64 => self.parse_rule_3338(skip_current_node), + 3339i64 => self.parse_rule_3339(skip_current_node), + 3340i64 => self.parse_rule_3340(skip_current_node), + 3341i64 => self.parse_rule_3341(skip_current_node), + 3342i64 => self.parse_rule_3342(skip_current_node), + 3343i64 => self.parse_rule_3343(skip_current_node), + 3344i64 => self.parse_rule_3344(skip_current_node), + 3345i64 => self.parse_rule_3345(skip_current_node), + 3346i64 => self.parse_rule_3346(skip_current_node), + 3347i64 => self.parse_rule_3347(skip_current_node), + 3348i64 => self.parse_rule_3348(skip_current_node), + 3349i64 => self.parse_rule_3349(skip_current_node), + 3350i64 => self.parse_rule_3350(skip_current_node), + 3351i64 => self.parse_rule_3351(skip_current_node), + 3352i64 => self.parse_rule_3352(skip_current_node), + 3353i64 => self.parse_rule_3353(skip_current_node), + 3354i64 => self.parse_rule_3354(skip_current_node), + 3355i64 => self.parse_rule_3355(skip_current_node), + 3356i64 => self.parse_rule_3356(skip_current_node), + 3357i64 => self.parse_rule_3357(skip_current_node), + 3358i64 => self.parse_rule_3358(skip_current_node), + 3359i64 => self.parse_rule_3359(skip_current_node), + 3360i64 => self.parse_rule_3360(skip_current_node), + 3361i64 => self.parse_rule_3361(skip_current_node), + 3362i64 => self.parse_rule_3362(skip_current_node), + 3363i64 => self.parse_rule_3363(skip_current_node), + 3364i64 => self.parse_rule_3364(skip_current_node), + 3365i64 => self.parse_rule_3365(skip_current_node), + 3366i64 => self.parse_rule_3366(skip_current_node), + 3367i64 => self.parse_rule_3367(skip_current_node), + 3368i64 => self.parse_rule_3368(skip_current_node), + 3369i64 => self.parse_rule_3369(skip_current_node), + 3370i64 => self.parse_rule_3370(skip_current_node), + 3371i64 => self.parse_rule_3371(skip_current_node), + 3372i64 => self.parse_rule_3372(skip_current_node), + 3373i64 => self.parse_rule_3373(skip_current_node), + 3374i64 => self.parse_rule_3374(skip_current_node), + 3375i64 => self.parse_rule_3375(skip_current_node), + 3376i64 => self.parse_rule_3376(skip_current_node), + 3377i64 => self.parse_rule_3377(skip_current_node), + 3378i64 => self.parse_rule_3378(skip_current_node), + 3379i64 => self.parse_rule_3379(skip_current_node), + 3380i64 => self.parse_rule_3380(skip_current_node), + 3381i64 => self.parse_rule_3381(skip_current_node), + 3382i64 => self.parse_rule_3382(skip_current_node), + 3383i64 => self.parse_rule_3383(skip_current_node), + 3384i64 => self.parse_rule_3384(skip_current_node), + 3385i64 => self.parse_rule_3385(skip_current_node), + 3386i64 => self.parse_rule_3386(skip_current_node), + 3387i64 => self.parse_rule_3387(skip_current_node), + 3388i64 => self.parse_rule_3388(skip_current_node), + 3389i64 => self.parse_rule_3389(skip_current_node), + 3390i64 => self.parse_rule_3390(skip_current_node), + 3391i64 => self.parse_rule_3391(skip_current_node), + 3392i64 => self.parse_rule_3392(skip_current_node), + 3393i64 => self.parse_rule_3393(skip_current_node), + 3394i64 => self.parse_rule_3394(skip_current_node), + 3395i64 => self.parse_rule_3395(skip_current_node), + 3396i64 => self.parse_rule_3396(skip_current_node), + 3397i64 => self.parse_rule_3397(skip_current_node), + 3398i64 => self.parse_rule_3398(skip_current_node), + 3399i64 => self.parse_rule_3399(skip_current_node), + 3400i64 => self.parse_rule_3400(skip_current_node), + 3401i64 => self.parse_rule_3401(skip_current_node), + 3402i64 => self.parse_rule_3402(skip_current_node), + 3403i64 => self.parse_rule_3403(skip_current_node), + 3404i64 => self.parse_rule_3404(skip_current_node), + 3405i64 => self.parse_rule_3405(skip_current_node), + 3406i64 => self.parse_rule_3406(skip_current_node), + 3407i64 => self.parse_rule_3407(skip_current_node), + 3408i64 => self.parse_rule_3408(skip_current_node), + 3409i64 => self.parse_rule_3409(skip_current_node), + 3410i64 => self.parse_rule_3410(skip_current_node), + 3411i64 => self.parse_rule_3411(skip_current_node), + 3412i64 => self.parse_rule_3412(skip_current_node), + 3413i64 => self.parse_rule_3413(skip_current_node), + 3414i64 => self.parse_rule_3414(skip_current_node), + 3415i64 => self.parse_rule_3415(skip_current_node), + 3416i64 => self.parse_rule_3416(skip_current_node), + 3417i64 => self.parse_rule_3417(skip_current_node), + 3418i64 => self.parse_rule_3418(skip_current_node), + 3419i64 => self.parse_rule_3419(skip_current_node), + 3420i64 => self.parse_rule_3420(skip_current_node), + 3421i64 => self.parse_rule_3421(skip_current_node), + 3422i64 => self.parse_rule_3422(skip_current_node), + 3423i64 => self.parse_rule_3423(skip_current_node), + 3424i64 => self.parse_rule_3424(skip_current_node), + 3425i64 => self.parse_rule_3425(skip_current_node), + 3426i64 => self.parse_rule_3426(skip_current_node), + 3427i64 => self.parse_rule_3427(skip_current_node), + 3428i64 => self.parse_rule_3428(skip_current_node), + 3429i64 => self.parse_rule_3429(skip_current_node), + 3430i64 => self.parse_rule_3430(skip_current_node), + 3431i64 => self.parse_rule_3431(skip_current_node), + 3432i64 => self.parse_rule_3432(skip_current_node), + 3433i64 => self.parse_rule_3433(skip_current_node), + 3434i64 => self.parse_rule_3434(skip_current_node), + 3435i64 => self.parse_rule_3435(skip_current_node), + 3436i64 => self.parse_rule_3436(skip_current_node), + 3437i64 => self.parse_rule_3437(skip_current_node), + 3438i64 => self.parse_rule_3438(skip_current_node), + 3439i64 => self.parse_rule_3439(skip_current_node), + 3440i64 => self.parse_rule_3440(skip_current_node), + 3441i64 => self.parse_rule_3441(skip_current_node), + 3442i64 => self.parse_rule_3442(skip_current_node), + 3443i64 => self.parse_rule_3443(skip_current_node), + 3444i64 => self.parse_rule_3444(skip_current_node), + 3445i64 => self.parse_rule_3445(skip_current_node), + 3446i64 => self.parse_rule_3446(skip_current_node), + 3447i64 => self.parse_rule_3447(skip_current_node), + 3448i64 => self.parse_rule_3448(skip_current_node), + 3449i64 => self.parse_rule_3449(skip_current_node), + 3450i64 => self.parse_rule_3450(skip_current_node), + 3451i64 => self.parse_rule_3451(skip_current_node), + 3452i64 => self.parse_rule_3452(skip_current_node), + 3453i64 => self.parse_rule_3453(skip_current_node), + 3454i64 => self.parse_rule_3454(skip_current_node), + 3455i64 => self.parse_rule_3455(skip_current_node), + 3456i64 => self.parse_rule_3456(skip_current_node), + 3457i64 => self.parse_rule_3457(skip_current_node), + 3458i64 => self.parse_rule_3458(skip_current_node), + 3459i64 => self.parse_rule_3459(skip_current_node), + 3460i64 => self.parse_rule_3460(skip_current_node), + 3461i64 => self.parse_rule_3461(skip_current_node), + 3462i64 => self.parse_rule_3462(skip_current_node), + 3463i64 => self.parse_rule_3463(skip_current_node), + 3464i64 => self.parse_rule_3464(skip_current_node), + 3465i64 => self.parse_rule_3465(skip_current_node), + 3466i64 => self.parse_rule_3466(skip_current_node), + 3467i64 => self.parse_rule_3467(skip_current_node), + 3468i64 => self.parse_rule_3468(skip_current_node), + 3469i64 => self.parse_rule_3469(skip_current_node), + 3470i64 => self.parse_rule_3470(skip_current_node), + 3471i64 => self.parse_rule_3471(skip_current_node), + 3472i64 => self.parse_rule_3472(skip_current_node), + 3473i64 => self.parse_rule_3473(skip_current_node), + 3474i64 => self.parse_rule_3474(skip_current_node), + 3475i64 => self.parse_rule_3475(skip_current_node), + 3476i64 => self.parse_rule_3476(skip_current_node), + 3477i64 => self.parse_rule_3477(skip_current_node), + 3478i64 => self.parse_rule_3478(skip_current_node), + 3479i64 => self.parse_rule_3479(skip_current_node), + 3480i64 => self.parse_rule_3480(skip_current_node), + 3481i64 => self.parse_rule_3481(skip_current_node), + 3482i64 => self.parse_rule_3482(skip_current_node), + 3483i64 => self.parse_rule_3483(skip_current_node), + 3484i64 => self.parse_rule_3484(skip_current_node), + 3485i64 => self.parse_rule_3485(skip_current_node), + 3486i64 => self.parse_rule_3486(skip_current_node), + 3487i64 => self.parse_rule_3487(skip_current_node), + 3488i64 => self.parse_rule_3488(skip_current_node), + 3489i64 => self.parse_rule_3489(skip_current_node), + 3490i64 => self.parse_rule_3490(skip_current_node), + 3491i64 => self.parse_rule_3491(skip_current_node), + 3492i64 => self.parse_rule_3492(skip_current_node), + 3493i64 => self.parse_rule_3493(skip_current_node), + 3494i64 => self.parse_rule_3494(skip_current_node), + 3495i64 => self.parse_rule_3495(skip_current_node), + 3496i64 => self.parse_rule_3496(skip_current_node), + 3497i64 => self.parse_rule_3497(skip_current_node), + 3498i64 => self.parse_rule_3498(skip_current_node), + 3499i64 => self.parse_rule_3499(skip_current_node), + 3500i64 => self.parse_rule_3500(skip_current_node), + 3501i64 => self.parse_rule_3501(skip_current_node), + 3502i64 => self.parse_rule_3502(skip_current_node), + 3503i64 => self.parse_rule_3503(skip_current_node), + 3504i64 => self.parse_rule_3504(skip_current_node), + 3505i64 => self.parse_rule_3505(skip_current_node), + 3506i64 => self.parse_rule_3506(skip_current_node), + 3507i64 => self.parse_rule_3507(skip_current_node), + 3508i64 => self.parse_rule_3508(skip_current_node), + 3509i64 => self.parse_rule_3509(skip_current_node), + 3510i64 => self.parse_rule_3510(skip_current_node), + 3511i64 => self.parse_rule_3511(skip_current_node), + 3512i64 => self.parse_rule_3512(skip_current_node), + 3513i64 => self.parse_rule_3513(skip_current_node), + 3514i64 => self.parse_rule_3514(skip_current_node), + 3515i64 => self.parse_rule_3515(skip_current_node), + 3516i64 => self.parse_rule_3516(skip_current_node), + 3517i64 => self.parse_rule_3517(skip_current_node), + 3518i64 => self.parse_rule_3518(skip_current_node), + 3519i64 => self.parse_rule_3519(skip_current_node), + 3520i64 => self.parse_rule_3520(skip_current_node), + 3521i64 => self.parse_rule_3521(skip_current_node), + 3522i64 => self.parse_rule_3522(skip_current_node), + 3523i64 => self.parse_rule_3523(skip_current_node), + 3524i64 => self.parse_rule_3524(skip_current_node), + 3525i64 => self.parse_rule_3525(skip_current_node), + 3526i64 => self.parse_rule_3526(skip_current_node), + 3527i64 => self.parse_rule_3527(skip_current_node), + 3528i64 => self.parse_rule_3528(skip_current_node), + 3529i64 => self.parse_rule_3529(skip_current_node), + 3530i64 => self.parse_rule_3530(skip_current_node), + 3531i64 => self.parse_rule_3531(skip_current_node), + 3532i64 => self.parse_rule_3532(skip_current_node), + 3533i64 => self.parse_rule_3533(skip_current_node), + 3534i64 => self.parse_rule_3534(skip_current_node), + 3535i64 => self.parse_rule_3535(skip_current_node), + 3536i64 => self.parse_rule_3536(skip_current_node), + 3537i64 => self.parse_rule_3537(skip_current_node), + 3538i64 => self.parse_rule_3538(skip_current_node), + 3539i64 => self.parse_rule_3539(skip_current_node), + 3540i64 => self.parse_rule_3540(skip_current_node), + 3541i64 => self.parse_rule_3541(skip_current_node), + 3542i64 => self.parse_rule_3542(skip_current_node), + 3543i64 => self.parse_rule_3543(skip_current_node), + 3544i64 => self.parse_rule_3544(skip_current_node), + 3545i64 => self.parse_rule_3545(skip_current_node), + 3546i64 => self.parse_rule_3546(skip_current_node), + 3547i64 => self.parse_rule_3547(skip_current_node), + 3548i64 => self.parse_rule_3548(skip_current_node), + 3549i64 => self.parse_rule_3549(skip_current_node), + 3550i64 => self.parse_rule_3550(skip_current_node), + 3551i64 => self.parse_rule_3551(skip_current_node), + 3552i64 => self.parse_rule_3552(skip_current_node), + 3553i64 => self.parse_rule_3553(skip_current_node), + 3554i64 => self.parse_rule_3554(skip_current_node), + 3555i64 => self.parse_rule_3555(skip_current_node), + 3556i64 => self.parse_rule_3556(skip_current_node), + 3557i64 => self.parse_rule_3557(skip_current_node), + 3558i64 => self.parse_rule_3558(skip_current_node), + 3559i64 => self.parse_rule_3559(skip_current_node), + 3560i64 => self.parse_rule_3560(skip_current_node), + 3561i64 => self.parse_rule_3561(skip_current_node), + 3562i64 => self.parse_rule_3562(skip_current_node), + 3563i64 => self.parse_rule_3563(skip_current_node), + 3564i64 => self.parse_rule_3564(skip_current_node), + 3565i64 => self.parse_rule_3565(skip_current_node), + 3566i64 => self.parse_rule_3566(skip_current_node), + 3567i64 => self.parse_rule_3567(skip_current_node), + 3568i64 => self.parse_rule_3568(skip_current_node), + 3569i64 => self.parse_rule_3569(skip_current_node), + 3570i64 => self.parse_rule_3570(skip_current_node), + 3571i64 => self.parse_rule_3571(skip_current_node), + 3572i64 => self.parse_rule_3572(skip_current_node), + 3573i64 => self.parse_rule_3573(skip_current_node), + 3574i64 => self.parse_rule_3574(skip_current_node), + 3575i64 => self.parse_rule_3575(skip_current_node), + 3576i64 => self.parse_rule_3576(skip_current_node), + 3577i64 => self.parse_rule_3577(skip_current_node), + 3578i64 => self.parse_rule_3578(skip_current_node), + 3579i64 => self.parse_rule_3579(skip_current_node), + 3580i64 => self.parse_rule_3580(skip_current_node), + 3581i64 => self.parse_rule_3581(skip_current_node), + 3582i64 => self.parse_rule_3582(skip_current_node), + 3583i64 => self.parse_rule_3583(skip_current_node), + 3584i64 => self.parse_rule_3584(skip_current_node), + 3585i64 => self.parse_rule_3585(skip_current_node), + 3586i64 => self.parse_rule_3586(skip_current_node), + 3587i64 => self.parse_rule_3587(skip_current_node), + 3588i64 => self.parse_rule_3588(skip_current_node), + 3589i64 => self.parse_rule_3589(skip_current_node), + 3590i64 => self.parse_rule_3590(skip_current_node), + 3591i64 => self.parse_rule_3591(skip_current_node), + 3592i64 => self.parse_rule_3592(skip_current_node), + 3593i64 => self.parse_rule_3593(skip_current_node), + 3594i64 => self.parse_rule_3594(skip_current_node), + 3595i64 => self.parse_rule_3595(skip_current_node), + 3596i64 => self.parse_rule_3596(skip_current_node), + 3597i64 => self.parse_rule_3597(skip_current_node), + 3598i64 => self.parse_rule_3598(skip_current_node), + 3599i64 => self.parse_rule_3599(skip_current_node), + 3600i64 => self.parse_rule_3600(skip_current_node), + 3601i64 => self.parse_rule_3601(skip_current_node), + 3602i64 => self.parse_rule_3602(skip_current_node), + 3603i64 => self.parse_rule_3603(skip_current_node), + 3604i64 => self.parse_rule_3604(skip_current_node), + 3605i64 => self.parse_rule_3605(skip_current_node), + 3606i64 => self.parse_rule_3606(skip_current_node), + 3607i64 => self.parse_rule_3607(skip_current_node), + 3608i64 => self.parse_rule_3608(skip_current_node), + 3609i64 => self.parse_rule_3609(skip_current_node), + 3610i64 => self.parse_rule_3610(skip_current_node), + 3611i64 => self.parse_rule_3611(skip_current_node), + 3612i64 => self.parse_rule_3612(skip_current_node), + 3613i64 => self.parse_rule_3613(skip_current_node), + 3614i64 => self.parse_rule_3614(skip_current_node), + 3615i64 => self.parse_rule_3615(skip_current_node), + 3616i64 => self.parse_rule_3616(skip_current_node), + 3617i64 => self.parse_rule_3617(skip_current_node), + 3618i64 => self.parse_rule_3618(skip_current_node), + 3619i64 => self.parse_rule_3619(skip_current_node), + 3620i64 => self.parse_rule_3620(skip_current_node), + 3621i64 => self.parse_rule_3621(skip_current_node), + 3622i64 => self.parse_rule_3622(skip_current_node), + 3623i64 => self.parse_rule_3623(skip_current_node), + 3624i64 => self.parse_rule_3624(skip_current_node), + 3625i64 => self.parse_rule_3625(skip_current_node), + 3626i64 => self.parse_rule_3626(skip_current_node), + 3627i64 => self.parse_rule_3627(skip_current_node), + 3628i64 => self.parse_rule_3628(skip_current_node), + 3629i64 => self.parse_rule_3629(skip_current_node), + 3630i64 => self.parse_rule_3630(skip_current_node), + 3631i64 => self.parse_rule_3631(skip_current_node), + 3632i64 => self.parse_rule_3632(skip_current_node), + 3633i64 => self.parse_rule_3633(skip_current_node), + 3634i64 => self.parse_rule_3634(skip_current_node), + 3635i64 => self.parse_rule_3635(skip_current_node), + 3636i64 => self.parse_rule_3636(skip_current_node), + 3637i64 => self.parse_rule_3637(skip_current_node), + 3638i64 => self.parse_rule_3638(skip_current_node), + 3639i64 => self.parse_rule_3639(skip_current_node), + 3640i64 => self.parse_rule_3640(skip_current_node), + 3641i64 => self.parse_rule_3641(skip_current_node), + 3642i64 => self.parse_rule_3642(skip_current_node), + 3643i64 => self.parse_rule_3643(skip_current_node), + 3644i64 => self.parse_rule_3644(skip_current_node), + 3645i64 => self.parse_rule_3645(skip_current_node), + 3646i64 => self.parse_rule_3646(skip_current_node), + 3647i64 => self.parse_rule_3647(skip_current_node), + 3648i64 => self.parse_rule_3648(skip_current_node), + 3649i64 => self.parse_rule_3649(skip_current_node), + 3650i64 => self.parse_rule_3650(skip_current_node), + 3651i64 => self.parse_rule_3651(skip_current_node), + 3652i64 => self.parse_rule_3652(skip_current_node), + 3653i64 => self.parse_rule_3653(skip_current_node), + 3654i64 => self.parse_rule_3654(skip_current_node), + 3655i64 => self.parse_rule_3655(skip_current_node), + 3656i64 => self.parse_rule_3656(skip_current_node), + 3657i64 => self.parse_rule_3657(skip_current_node), + 3658i64 => self.parse_rule_3658(skip_current_node), + 3659i64 => self.parse_rule_3659(skip_current_node), + 3660i64 => self.parse_rule_3660(skip_current_node), + 3661i64 => self.parse_rule_3661(skip_current_node), + 3662i64 => self.parse_rule_3662(skip_current_node), + 3663i64 => self.parse_rule_3663(skip_current_node), + 3664i64 => self.parse_rule_3664(skip_current_node), + 3665i64 => self.parse_rule_3665(skip_current_node), + 3666i64 => self.parse_rule_3666(skip_current_node), + 3667i64 => self.parse_rule_3667(skip_current_node), + 3668i64 => self.parse_rule_3668(skip_current_node), + 3669i64 => self.parse_rule_3669(skip_current_node), + 3670i64 => self.parse_rule_3670(skip_current_node), + 3671i64 => self.parse_rule_3671(skip_current_node), + 3672i64 => self.parse_rule_3672(skip_current_node), + 3673i64 => self.parse_rule_3673(skip_current_node), + 3674i64 => self.parse_rule_3674(skip_current_node), + 3675i64 => self.parse_rule_3675(skip_current_node), + 3676i64 => self.parse_rule_3676(skip_current_node), + 3677i64 => self.parse_rule_3677(skip_current_node), + 3678i64 => self.parse_rule_3678(skip_current_node), + 3679i64 => self.parse_rule_3679(skip_current_node), + 3680i64 => self.parse_rule_3680(skip_current_node), + 3681i64 => self.parse_rule_3681(skip_current_node), + 3682i64 => self.parse_rule_3682(skip_current_node), + 3683i64 => self.parse_rule_3683(skip_current_node), + 3684i64 => self.parse_rule_3684(skip_current_node), + 3685i64 => self.parse_rule_3685(skip_current_node), + 3686i64 => self.parse_rule_3686(skip_current_node), + 3687i64 => self.parse_rule_3687(skip_current_node), + 3688i64 => self.parse_rule_3688(skip_current_node), + 3689i64 => self.parse_rule_3689(skip_current_node), + 3690i64 => self.parse_rule_3690(skip_current_node), + 3691i64 => self.parse_rule_3691(skip_current_node), + 3692i64 => self.parse_rule_3692(skip_current_node), + 3693i64 => self.parse_rule_3693(skip_current_node), + 3694i64 => self.parse_rule_3694(skip_current_node), + 3695i64 => self.parse_rule_3695(skip_current_node), + 3696i64 => self.parse_rule_3696(skip_current_node), + 3697i64 => self.parse_rule_3697(skip_current_node), + 3698i64 => self.parse_rule_3698(skip_current_node), + 3699i64 => self.parse_rule_3699(skip_current_node), + 3700i64 => self.parse_rule_3700(skip_current_node), + 3701i64 => self.parse_rule_3701(skip_current_node), + 3702i64 => self.parse_rule_3702(skip_current_node), + 3703i64 => self.parse_rule_3703(skip_current_node), + 3704i64 => self.parse_rule_3704(skip_current_node), + 3705i64 => self.parse_rule_3705(skip_current_node), + 3706i64 => self.parse_rule_3706(skip_current_node), + 3707i64 => self.parse_rule_3707(skip_current_node), + 3708i64 => self.parse_rule_3708(skip_current_node), + 3709i64 => self.parse_rule_3709(skip_current_node), + 3710i64 => self.parse_rule_3710(skip_current_node), + 3711i64 => self.parse_rule_3711(skip_current_node), + 3712i64 => self.parse_rule_3712(skip_current_node), + 3713i64 => self.parse_rule_3713(skip_current_node), + 3714i64 => self.parse_rule_3714(skip_current_node), + 3715i64 => self.parse_rule_3715(skip_current_node), + 3716i64 => self.parse_rule_3716(skip_current_node), + 3717i64 => self.parse_rule_3717(skip_current_node), + 3718i64 => self.parse_rule_3718(skip_current_node), + 3719i64 => self.parse_rule_3719(skip_current_node), + 3720i64 => self.parse_rule_3720(skip_current_node), + 3721i64 => self.parse_rule_3721(skip_current_node), + 3722i64 => self.parse_rule_3722(skip_current_node), + 3723i64 => self.parse_rule_3723(skip_current_node), + 3724i64 => self.parse_rule_3724(skip_current_node), + 3725i64 => self.parse_rule_3725(skip_current_node), + 3726i64 => self.parse_rule_3726(skip_current_node), + 3727i64 => self.parse_rule_3727(skip_current_node), + 3728i64 => self.parse_rule_3728(skip_current_node), + 3729i64 => self.parse_rule_3729(skip_current_node), + 3730i64 => self.parse_rule_3730(skip_current_node), + 3731i64 => self.parse_rule_3731(skip_current_node), + 3732i64 => self.parse_rule_3732(skip_current_node), + 3733i64 => self.parse_rule_3733(skip_current_node), + 3734i64 => self.parse_rule_3734(skip_current_node), + 3735i64 => self.parse_rule_3735(skip_current_node), + 3736i64 => self.parse_rule_3736(skip_current_node), + 3737i64 => self.parse_rule_3737(skip_current_node), + 3738i64 => self.parse_rule_3738(skip_current_node), + 3739i64 => self.parse_rule_3739(skip_current_node), + 3740i64 => self.parse_rule_3740(skip_current_node), + 3741i64 => self.parse_rule_3741(skip_current_node), + 3742i64 => self.parse_rule_3742(skip_current_node), + 3743i64 => self.parse_rule_3743(skip_current_node), + 3744i64 => self.parse_rule_3744(skip_current_node), + 3745i64 => self.parse_rule_3745(skip_current_node), + 3746i64 => self.parse_rule_3746(skip_current_node), + 3747i64 => self.parse_rule_3747(skip_current_node), + 3748i64 => self.parse_rule_3748(skip_current_node), + 3749i64 => self.parse_rule_3749(skip_current_node), + 3750i64 => self.parse_rule_3750(skip_current_node), + 3751i64 => self.parse_rule_3751(skip_current_node), + 3752i64 => self.parse_rule_3752(skip_current_node), + 3753i64 => self.parse_rule_3753(skip_current_node), + 3754i64 => self.parse_rule_3754(skip_current_node), + 3755i64 => self.parse_rule_3755(skip_current_node), + 3756i64 => self.parse_rule_3756(skip_current_node), + 3757i64 => self.parse_rule_3757(skip_current_node), + 3758i64 => self.parse_rule_3758(skip_current_node), + 3759i64 => self.parse_rule_3759(skip_current_node), + 3760i64 => self.parse_rule_3760(skip_current_node), + 3761i64 => self.parse_rule_3761(skip_current_node), + 3762i64 => self.parse_rule_3762(skip_current_node), + 3763i64 => self.parse_rule_3763(skip_current_node), + 3764i64 => self.parse_rule_3764(skip_current_node), + 3765i64 => self.parse_rule_3765(skip_current_node), + 3766i64 => self.parse_rule_3766(skip_current_node), + 3767i64 => self.parse_rule_3767(skip_current_node), + 3768i64 => self.parse_rule_3768(skip_current_node), + 3769i64 => self.parse_rule_3769(skip_current_node), + 3770i64 => self.parse_rule_3770(skip_current_node), + 3771i64 => self.parse_rule_3771(skip_current_node), + 3772i64 => self.parse_rule_3772(skip_current_node), + 3773i64 => self.parse_rule_3773(skip_current_node), + 3774i64 => self.parse_rule_3774(skip_current_node), + 3775i64 => self.parse_rule_3775(skip_current_node), + 3776i64 => self.parse_rule_3776(skip_current_node), + 3777i64 => self.parse_rule_3777(skip_current_node), + 3778i64 => self.parse_rule_3778(skip_current_node), + 3779i64 => self.parse_rule_3779(skip_current_node), + 3780i64 => self.parse_rule_3780(skip_current_node), + 3781i64 => self.parse_rule_3781(skip_current_node), + 3782i64 => self.parse_rule_3782(skip_current_node), + 3783i64 => self.parse_rule_3783(skip_current_node), + 3784i64 => self.parse_rule_3784(skip_current_node), + 3785i64 => self.parse_rule_3785(skip_current_node), + 3786i64 => self.parse_rule_3786(skip_current_node), + 3787i64 => self.parse_rule_3787(skip_current_node), + 3788i64 => self.parse_rule_3788(skip_current_node), + 3789i64 => self.parse_rule_3789(skip_current_node), + 3790i64 => self.parse_rule_3790(skip_current_node), + 3791i64 => self.parse_rule_3791(skip_current_node), + 3792i64 => self.parse_rule_3792(skip_current_node), + 3793i64 => self.parse_rule_3793(skip_current_node), + 3794i64 => self.parse_rule_3794(skip_current_node), + 3795i64 => self.parse_rule_3795(skip_current_node), + 3796i64 => self.parse_rule_3796(skip_current_node), + 3797i64 => self.parse_rule_3797(skip_current_node), + 3798i64 => self.parse_rule_3798(skip_current_node), + 3799i64 => self.parse_rule_3799(skip_current_node), + 3800i64 => self.parse_rule_3800(skip_current_node), + 3801i64 => self.parse_rule_3801(skip_current_node), + 3802i64 => self.parse_rule_3802(skip_current_node), + 3803i64 => self.parse_rule_3803(skip_current_node), + 3804i64 => self.parse_rule_3804(skip_current_node), + 3805i64 => self.parse_rule_3805(skip_current_node), + 3806i64 => self.parse_rule_3806(skip_current_node), + 3807i64 => self.parse_rule_3807(skip_current_node), + 3808i64 => self.parse_rule_3808(skip_current_node), + 3809i64 => self.parse_rule_3809(skip_current_node), + 3810i64 => self.parse_rule_3810(skip_current_node), + 3811i64 => self.parse_rule_3811(skip_current_node), + 3812i64 => self.parse_rule_3812(skip_current_node), + 3813i64 => self.parse_rule_3813(skip_current_node), + 3814i64 => self.parse_rule_3814(skip_current_node), + 3815i64 => self.parse_rule_3815(skip_current_node), + 3816i64 => self.parse_rule_3816(skip_current_node), + 3817i64 => self.parse_rule_3817(skip_current_node), + 3818i64 => self.parse_rule_3818(skip_current_node), + 3819i64 => self.parse_rule_3819(skip_current_node), + 3820i64 => self.parse_rule_3820(skip_current_node), + 3821i64 => self.parse_rule_3821(skip_current_node), + 3822i64 => self.parse_rule_3822(skip_current_node), + 3823i64 => self.parse_rule_3823(skip_current_node), + 3824i64 => self.parse_rule_3824(skip_current_node), + 3825i64 => self.parse_rule_3825(skip_current_node), + 3826i64 => self.parse_rule_3826(skip_current_node), + 3827i64 => self.parse_rule_3827(skip_current_node), + 3828i64 => self.parse_rule_3828(skip_current_node), + 3829i64 => self.parse_rule_3829(skip_current_node), + 3830i64 => self.parse_rule_3830(skip_current_node), + 3831i64 => self.parse_rule_3831(skip_current_node), + 3832i64 => self.parse_rule_3832(skip_current_node), + 3833i64 => self.parse_rule_3833(skip_current_node), + 3834i64 => self.parse_rule_3834(skip_current_node), + 3835i64 => self.parse_rule_3835(skip_current_node), + 3836i64 => self.parse_rule_3836(skip_current_node), + 3837i64 => self.parse_rule_3837(skip_current_node), + 3838i64 => self.parse_rule_3838(skip_current_node), + 3839i64 => self.parse_rule_3839(skip_current_node), + 3840i64 => self.parse_rule_3840(skip_current_node), + 3841i64 => self.parse_rule_3841(skip_current_node), + 3842i64 => self.parse_rule_3842(skip_current_node), + 3843i64 => self.parse_rule_3843(skip_current_node), + 3844i64 => self.parse_rule_3844(skip_current_node), + 3845i64 => self.parse_rule_3845(skip_current_node), + 3846i64 => self.parse_rule_3846(skip_current_node), + 3847i64 => self.parse_rule_3847(skip_current_node), + 3848i64 => self.parse_rule_3848(skip_current_node), + 3849i64 => self.parse_rule_3849(skip_current_node), + 3850i64 => self.parse_rule_3850(skip_current_node), + 3851i64 => self.parse_rule_3851(skip_current_node), + 3852i64 => self.parse_rule_3852(skip_current_node), + 3853i64 => self.parse_rule_3853(skip_current_node), + 3854i64 => self.parse_rule_3854(skip_current_node), + 3855i64 => self.parse_rule_3855(skip_current_node), + 3856i64 => self.parse_rule_3856(skip_current_node), + 3857i64 => self.parse_rule_3857(skip_current_node), + 3858i64 => self.parse_rule_3858(skip_current_node), + 3859i64 => self.parse_rule_3859(skip_current_node), + 3860i64 => self.parse_rule_3860(skip_current_node), + 3861i64 => self.parse_rule_3861(skip_current_node), + 3862i64 => self.parse_rule_3862(skip_current_node), + 3863i64 => self.parse_rule_3863(skip_current_node), + 3864i64 => self.parse_rule_3864(skip_current_node), + 3865i64 => self.parse_rule_3865(skip_current_node), + 3866i64 => self.parse_rule_3866(skip_current_node), + 3867i64 => self.parse_rule_3867(skip_current_node), + 3868i64 => self.parse_rule_3868(skip_current_node), + 3869i64 => self.parse_rule_3869(skip_current_node), + 3870i64 => self.parse_rule_3870(skip_current_node), + 3871i64 => self.parse_rule_3871(skip_current_node), + 3872i64 => self.parse_rule_3872(skip_current_node), + 3873i64 => self.parse_rule_3873(skip_current_node), + 3874i64 => self.parse_rule_3874(skip_current_node), + 3875i64 => self.parse_rule_3875(skip_current_node), + 3876i64 => self.parse_rule_3876(skip_current_node), + 3877i64 => self.parse_rule_3877(skip_current_node), + 3878i64 => self.parse_rule_3878(skip_current_node), + 3879i64 => self.parse_rule_3879(skip_current_node), + 3880i64 => self.parse_rule_3880(skip_current_node), + 3881i64 => self.parse_rule_3881(skip_current_node), + 3882i64 => self.parse_rule_3882(skip_current_node), + 3883i64 => self.parse_rule_3883(skip_current_node), + 3884i64 => self.parse_rule_3884(skip_current_node), + 3885i64 => self.parse_rule_3885(skip_current_node), + 3886i64 => self.parse_rule_3886(skip_current_node), + 3887i64 => self.parse_rule_3887(skip_current_node), + 3888i64 => self.parse_rule_3888(skip_current_node), + 3889i64 => self.parse_rule_3889(skip_current_node), + 3890i64 => self.parse_rule_3890(skip_current_node), + 3891i64 => self.parse_rule_3891(skip_current_node), + 3892i64 => self.parse_rule_3892(skip_current_node), + 3893i64 => self.parse_rule_3893(skip_current_node), + 3894i64 => self.parse_rule_3894(skip_current_node), + 3895i64 => self.parse_rule_3895(skip_current_node), + 3896i64 => self.parse_rule_3896(skip_current_node), + 3897i64 => self.parse_rule_3897(skip_current_node), + 3898i64 => self.parse_rule_3898(skip_current_node), + 3899i64 => self.parse_rule_3899(skip_current_node), + 3900i64 => self.parse_rule_3900(skip_current_node), + 3901i64 => self.parse_rule_3901(skip_current_node), + 3902i64 => self.parse_rule_3902(skip_current_node), + 3903i64 => self.parse_rule_3903(skip_current_node), + 3904i64 => self.parse_rule_3904(skip_current_node), + 3905i64 => self.parse_rule_3905(skip_current_node), + 3906i64 => self.parse_rule_3906(skip_current_node), + 3907i64 => self.parse_rule_3907(skip_current_node), + 3908i64 => self.parse_rule_3908(skip_current_node), + 3909i64 => self.parse_rule_3909(skip_current_node), + 3910i64 => self.parse_rule_3910(skip_current_node), + 3911i64 => self.parse_rule_3911(skip_current_node), + 3912i64 => self.parse_rule_3912(skip_current_node), + 3913i64 => self.parse_rule_3913(skip_current_node), + 3914i64 => self.parse_rule_3914(skip_current_node), + 3915i64 => self.parse_rule_3915(skip_current_node), + _ => CompiledMatch::No, + } + } + + // query + fn parse_rule_2000(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + -1i64 | 11i64 | 14i64 | 29i64 | 33i64 | 47i64 | 48i64 | 55i64 | 61i64 | 62i64 | 77i64 | 97i64 | 123i64 | 133i64 | 134i64 | 135i64 | 147i64 | 148i64 | + 173i64 | 178i64 | 196i64 | 207i64 | 215i64 | 219i64 | 222i64 | 234i64 | 242i64 | 245i64 | 266i64 | 281i64 | 287i64 | 388i64 | 417i64 | 428i64 | 450i64 | 453i64 | + 455i64 | 458i64 | 468i64 | 469i64 | 477i64 | 480i64 | 489i64 | 497i64 | 506i64 | 509i64 | 510i64 | 511i64 | 543i64 | 552i64 | 574i64 | 597i64 | 607i64 | 611i64 | + 614i64 | 620i64 | 626i64 | 645i64 | 651i64 | 677i64 | 714i64 | 753i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2000i64); + } + self.parse_child(-1i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2000i64); + } + self.parse_child(2001i64, &mut branch_matches, &mut has_children); + self.parse_child(2003i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1 + fn parse_rule_2001(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 11i64 | 14i64 | 29i64 | 33i64 | 47i64 | 48i64 | 55i64 | 61i64 | 62i64 | 77i64 | 97i64 | 123i64 | 133i64 | 134i64 | 135i64 | 147i64 | 148i64 | 173i64 | + 178i64 | 196i64 | 207i64 | 215i64 | 219i64 | 222i64 | 234i64 | 242i64 | 245i64 | 266i64 | 281i64 | 287i64 | 388i64 | 417i64 | 428i64 | 450i64 | 453i64 | 455i64 | + 458i64 | 468i64 | 469i64 | 477i64 | 480i64 | 489i64 | 497i64 | 506i64 | 509i64 | 510i64 | 511i64 | 543i64 | 552i64 | 574i64 | 597i64 | 607i64 | 611i64 | 614i64 | + 620i64 | 626i64 | 645i64 | 651i64 | 677i64 | 714i64 | 753i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2004i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2668i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f2 + fn parse_rule_2002(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(-1i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f3 + fn parse_rule_2003(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), -1i64 | 755i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(755i64, &mut branch_matches, &mut has_children); + self.parse_child(2002i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(-1i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // simpleStatement + fn parse_rule_2004(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 11i64 | 14i64 | 33i64 | 47i64 | 48i64 | 55i64 | 61i64 | 62i64 | 77i64 | 97i64 | 123i64 | 133i64 | 134i64 | 135i64 | 147i64 | 148i64 | 173i64 | 178i64 | + 196i64 | 207i64 | 215i64 | 219i64 | 222i64 | 234i64 | 242i64 | 245i64 | 266i64 | 281i64 | 287i64 | 388i64 | 417i64 | 428i64 | 450i64 | 453i64 | 455i64 | 458i64 | + 468i64 | 469i64 | 477i64 | 480i64 | 489i64 | 497i64 | 506i64 | 509i64 | 510i64 | 511i64 | 543i64 | 552i64 | 574i64 | 597i64 | 607i64 | 611i64 | 614i64 | 620i64 | + 626i64 | 645i64 | 651i64 | 677i64 | 714i64 | 753i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2009i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2175i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2318i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2353i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2358i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2359i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2361i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2366i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2381i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2400i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2437i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2457i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2461i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2656i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2659i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2712i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2829i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2838i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2848i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(2991i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3010i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3020i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3057i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3145i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3102i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3472i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3489i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2004i64); + } + self.parse_child(3496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f4 + fn parse_rule_2005(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 234i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2359i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f5 + fn parse_rule_2006(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 677i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2838i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f6 + fn parse_rule_2007(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64 | 97i64 | 148i64 | 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3145i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f7 + fn parse_rule_2008(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 207i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3472i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterStatement + fn parse_rule_2009(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2009i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(2012i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f8 + fn parse_rule_2010(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2153i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f9 + fn parse_rule_2011(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f10 + fn parse_rule_2012(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 109i64 | 130i64 | 170i64 | 206i64 | 232i64 | 244i64 | 288i64 | 380i64 | 385i64 | 422i64 | 503i64 | 537i64 | 572i64 | 574i64 | 605i64 | 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2060i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2028i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(3783i64, &mut branch_matches, &mut has_children); + self.parse_child(2011i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(3785i64, &mut branch_matches, &mut has_children); + self.parse_child(2011i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2167i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2039i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2140i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2153i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2050i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2056i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2013i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterInstance + fn parse_rule_2013(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 244i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2013i64); + } + self.parse_child(244i64, &mut branch_matches, &mut has_children); + self.parse_child(2025i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f11 + fn parse_rule_2014(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 33i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(33i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f12 + fn parse_rule_2015(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 33i64 | 844i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(33i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f13 + fn parse_rule_2016(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(480i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f14 + fn parse_rule_2017(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 373i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(480i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f15 + fn parse_rule_2018(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 451i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + self.parse_child(845i64, &mut branch_matches, &mut has_children); + self.parse_child(2016i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f16 + fn parse_rule_2019(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(480i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f17 + fn parse_rule_2020(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 373i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(480i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f18 + fn parse_rule_2021(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 451i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + self.parse_child(845i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(57i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2019i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f19 + fn parse_rule_2022(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 140i64 | 156i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(140i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f20 + fn parse_rule_2023(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 140i64 | 156i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2022i64, &mut branch_matches, &mut has_children); + self.parse_child(844i64, &mut branch_matches, &mut has_children); + self.parse_child(846i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f21 + fn parse_rule_2024(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 451i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + self.parse_child(847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f22 + fn parse_rule_2025(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 140i64 | 156i64 | 451i64 | 482i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(482i64, &mut branch_matches, &mut has_children); + self.parse_child(2015i64, &mut branch_matches, &mut has_children); + self.parse_child(316i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + self.parse_child(845i64, &mut branch_matches, &mut has_children); + self.parse_child(2016i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + self.parse_child(845i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(57i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2019i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2022i64, &mut branch_matches, &mut has_children); + self.parse_child(844i64, &mut branch_matches, &mut has_children); + self.parse_child(846i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + self.parse_child(847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f23 + fn parse_rule_2026(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 244i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + self.parse_child(2025i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f24 + fn parse_rule_2027(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterDatabase + fn parse_rule_2028(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 109i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2028i64); + } + self.parse_child(109i64, &mut branch_matches, &mut has_children); + self.parse_child(2027i64, &mut branch_matches, &mut has_children); + self.parse_child(2031i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f25 + fn parse_rule_2029(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 615i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(615i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(357i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f26 + fn parse_rule_2030(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64 | 69i64 | 128i64 | 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2183i64, &mut branch_matches, &mut has_children); + self.parse_child(2030i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2183i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f27 + fn parse_rule_2031(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64 | 69i64 | 128i64 | 158i64 | 615i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2030i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(615i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(357i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f28 + fn parse_rule_2032(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3690i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f29 + fn parse_rule_2033(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(490i64, &mut branch_matches, &mut has_children); + self.parse_child(3510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f30 + fn parse_rule_2034(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(79i64, &mut branch_matches, &mut has_children); + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f31 + fn parse_rule_2035(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f32 + fn parse_rule_2036(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2046i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f33 + fn parse_rule_2037(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f34 + fn parse_rule_2038(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(147i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterEvent + fn parse_rule_2039(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 170i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2039i64); + } + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(170i64, &mut branch_matches, &mut has_children); + self.parse_child(3797i64, &mut branch_matches, &mut has_children); + self.parse_child(2033i64, &mut branch_matches, &mut has_children); + self.parse_child(2034i64, &mut branch_matches, &mut has_children); + self.parse_child(2035i64, &mut branch_matches, &mut has_children); + self.parse_child(2036i64, &mut branch_matches, &mut has_children); + self.parse_child(2037i64, &mut branch_matches, &mut has_children); + self.parse_child(2038i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f35 + fn parse_rule_2040(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(490i64, &mut branch_matches, &mut has_children); + self.parse_child(3510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f36 + fn parse_rule_2041(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(371i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f37 + fn parse_rule_2042(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(79i64, &mut branch_matches, &mut has_children); + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f38 + fn parse_rule_2043(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 453i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f39 + fn parse_rule_2044(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f40 + fn parse_rule_2045(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f41 + fn parse_rule_2046(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 140i64 | 156i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(140i64, &mut branch_matches, &mut has_children); + self.parse_child(2044i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f42 + fn parse_rule_2047(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f43 + fn parse_rule_2048(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 147i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(147i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f44 + fn parse_rule_2049(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2052i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterLogfileGroup + fn parse_rule_2050(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 288i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2050i64); + } + self.parse_child(288i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3795i64, &mut branch_matches, &mut has_children); + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(603i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(2049i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f45 + fn parse_rule_2051(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2055i64, &mut branch_matches, &mut has_children); + self.parse_child(2051i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2055i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterLogfileGroupOptions + fn parse_rule_2052(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 238i64 | 374i64 | 553i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2052i64); + } + self.parse_child(2055i64, &mut branch_matches, &mut has_children); + self.parse_child(2051i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f46 + fn parse_rule_2053(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f47 + fn parse_rule_2054(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 238i64 | 374i64 | 553i64 | 638i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2055i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterLogfileGroupOption + fn parse_rule_2055(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 238i64 | 374i64 | 553i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2055i64); + } + self.parse_child(2274i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2055i64); + } + self.parse_child(2282i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2055i64); + } + self.parse_child(2284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterServer + fn parse_rule_2056(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 503i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2056i64); + } + self.parse_child(503i64, &mut branch_matches, &mut has_children); + self.parse_child(3800i64, &mut branch_matches, &mut has_children); + self.parse_child(2254i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f48 + fn parse_rule_2057(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3761i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f49 + fn parse_rule_2058(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f50 + fn parse_rule_2059(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2065i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterTable + fn parse_rule_2060(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64 | 380i64 | 385i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2060i64); + } + self.parse_child(2057i64, &mut branch_matches, &mut has_children); + self.parse_child(2058i64, &mut branch_matches, &mut has_children); + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2059i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f51 + fn parse_rule_2061(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f52 + fn parse_rule_2062(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f53 + fn parse_rule_2063(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2072i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f54 + fn parse_rule_2064(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2067i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterTableActions + fn parse_rule_2065(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 4i64 | 9i64 | 11i64 | 14i64 | 23i64 | 24i64 | 25i64 | 55i64 | 58i64 | 60i64 | 61i64 | 62i64 | 67i64 | 69i64 | 75i64 | 81i64 | 84i64 | 94i64 | + 112i64 | 128i64 | 132i64 | 140i64 | 141i64 | 148i64 | 156i64 | 158i64 | 163i64 | 172i64 | 198i64 | 234i64 | 236i64 | 243i64 | 264i64 | 287i64 | 323i64 | 344i64 | + 348i64 | 388i64 | 393i64 | 399i64 | 405i64 | 406i64 | 438i64 | 452i64 | 453i64 | 454i64 | 455i64 | 486i64 | 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | + 575i64 | 597i64 | 608i64 | 615i64 | 645i64 | 646i64 | 721i64 | 722i64 | 723i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2065i64); + } + self.parse_child(2063i64, &mut branch_matches, &mut has_children); + self.parse_child(2074i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2065i64); + } + self.parse_child(2069i64, &mut branch_matches, &mut has_children); + self.parse_child(2064i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2065i64); + } + self.parse_child(3653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2065i64); + } + self.parse_child(2138i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f55 + fn parse_rule_2066(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 287i64 | 645i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2072i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f56 + fn parse_rule_2067(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64 | 452i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2138i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f57 + fn parse_rule_2068(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2088i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterCommandList + fn parse_rule_2069(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 4i64 | 9i64 | 11i64 | 23i64 | 24i64 | 25i64 | 55i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 94i64 | 112i64 | 128i64 | 132i64 | + 140i64 | 148i64 | 156i64 | 158i64 | 163i64 | 198i64 | 236i64 | 243i64 | 264i64 | 287i64 | 323i64 | 344i64 | 348i64 | 393i64 | 399i64 | 406i64 | 453i64 | 486i64 | + 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 615i64 | 645i64 | 646i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2069i64); + } + self.parse_child(2072i64, &mut branch_matches, &mut has_children); + self.parse_child(2068i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2069i64); + } + self.parse_child(2088i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f58 + fn parse_rule_2070(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2088i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f59 + fn parse_rule_2071(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2092i64, &mut branch_matches, &mut has_children); + self.parse_child(2071i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2092i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterCommandsModifierList + fn parse_rule_2072(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 287i64 | 645i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2072i64); + } + self.parse_child(2092i64, &mut branch_matches, &mut has_children); + self.parse_child(2071i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f60 + fn parse_rule_2073(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2092i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // standaloneAlterCommands + fn parse_rule_2074(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 4i64 | 14i64 | 62i64 | 67i64 | 141i64 | 148i64 | 172i64 | 234i64 | 388i64 | 438i64 | 454i64 | 455i64 | 597i64 | 722i64 | 723i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2074i64); + } + self.parse_child(141i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2074i64); + } + self.parse_child(234i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2074i64); + } + self.parse_child(2082i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2074i64); + } + self.parse_child(2075i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f61 + fn parse_rule_2075(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 722i64 | 723i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(722i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f62 + fn parse_rule_2076(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 722i64 | 723i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2075i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f63 + fn parse_rule_2077(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3762i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f64 + fn parse_rule_2078(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3005i64, &mut branch_matches, &mut has_children); + self.parse_child(2078i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3005i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f65 + fn parse_rule_2079(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3007i64, &mut branch_matches, &mut has_children); + self.parse_child(2079i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3007i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f66 + fn parse_rule_2080(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(248i64, &mut branch_matches, &mut has_children); + self.parse_child(3668i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f67 + fn parse_rule_2081(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2135i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterPartition + fn parse_rule_2082(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 4i64 | 14i64 | 62i64 | 67i64 | 141i64 | 148i64 | 172i64 | 234i64 | 388i64 | 438i64 | 454i64 | 455i64 | 597i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2083i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(438i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(388i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(14i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(2078i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(455i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(2079i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(67i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(597i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(454i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2080i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(172i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2081i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(141i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2082i64); + } + self.parse_child(234i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f68 + fn parse_rule_2083(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 404i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3668i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f69 + fn parse_rule_2084(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(248i64, &mut branch_matches, &mut has_children); + self.parse_child(3668i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f70 + fn parse_rule_2085(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 141i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(141i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f71 + fn parse_rule_2086(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 234i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(234i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f72 + fn parse_rule_2087(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2090i64, &mut branch_matches, &mut has_children); + self.parse_child(2087i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2090i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterList + fn parse_rule_2088(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 4i64 | 11i64 | 23i64 | 24i64 | 25i64 | 55i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 94i64 | 112i64 | 128i64 | 132i64 | 140i64 | + 148i64 | 156i64 | 158i64 | 163i64 | 198i64 | 236i64 | 243i64 | 264i64 | 323i64 | 344i64 | 348i64 | 393i64 | 399i64 | 406i64 | 453i64 | 486i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 615i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2088i64); + } + self.parse_child(2089i64, &mut branch_matches, &mut has_children); + self.parse_child(2087i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f73 + fn parse_rule_2089(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 4i64 | 11i64 | 23i64 | 24i64 | 25i64 | 55i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 94i64 | 112i64 | 128i64 | 132i64 | 140i64 | + 148i64 | 156i64 | 158i64 | 163i64 | 198i64 | 236i64 | 243i64 | 264i64 | 323i64 | 344i64 | 348i64 | 393i64 | 399i64 | 406i64 | 453i64 | 486i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 615i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2097i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f74 + fn parse_rule_2090(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 4i64 | 9i64 | 11i64 | 23i64 | 24i64 | 25i64 | 55i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 94i64 | 112i64 | 128i64 | 132i64 | + 140i64 | 148i64 | 156i64 | 158i64 | 163i64 | 198i64 | 236i64 | 243i64 | 264i64 | 287i64 | 323i64 | 344i64 | 348i64 | 393i64 | 399i64 | 406i64 | 453i64 | 486i64 | + 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 615i64 | 645i64 | 646i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2097i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2092i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f75 + fn parse_rule_2091(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2090i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterCommandsModifier + fn parse_rule_2092(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 287i64 | 645i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2092i64); + } + self.parse_child(2128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2092i64); + } + self.parse_child(2130i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2092i64); + } + self.parse_child(2135i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f76 + fn parse_rule_2093(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(72i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f77 + fn parse_rule_2094(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2121i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f78 + fn parse_rule_2095(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2116i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f79 + fn parse_rule_2096(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterListItem + fn parse_rule_2097(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 4i64 | 11i64 | 55i64 | 94i64 | 140i64 | 148i64 | 156i64 | 198i64 | 348i64 | 393i64 | 453i64 | 615i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(2093i64, &mut branch_matches, &mut has_children); + self.parse_child(2099i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(3519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(55i64, &mut branch_matches, &mut has_children); + self.parse_child(2093i64, &mut branch_matches, &mut has_children); + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3528i64, &mut branch_matches, &mut has_children); + self.parse_child(2094i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(348i64, &mut branch_matches, &mut has_children); + self.parse_child(2093i64, &mut branch_matches, &mut has_children); + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(3528i64, &mut branch_matches, &mut has_children); + self.parse_child(2094i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(2107i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(140i64, &mut branch_matches, &mut has_children); + self.parse_child(263i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(156i64, &mut branch_matches, &mut has_children); + self.parse_child(263i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(2093i64, &mut branch_matches, &mut has_children); + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(2111i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(3776i64, &mut branch_matches, &mut has_children); + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(86i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(72i64, &mut branch_matches, &mut has_children); + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(2095i64, &mut branch_matches, &mut has_children); + self.parse_child(3802i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + self.parse_child(3776i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(94i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(2119i64, &mut branch_matches, &mut has_children); + self.parse_child(2096i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(198i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(393i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(2125i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2097i64); + } + self.parse_child(615i64, &mut branch_matches, &mut has_children); + self.parse_child(403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f80 + fn parse_rule_2098(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f81 + fn parse_rule_2099(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3528i64, &mut branch_matches, &mut has_children); + self.parse_child(2098i64, &mut branch_matches, &mut has_children); + self.parse_child(2094i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2194i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f82 + fn parse_rule_2100(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f83 + fn parse_rule_2101(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f84 + fn parse_rule_2102(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2101i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f85 + fn parse_rule_2103(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2101i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f86 + fn parse_rule_2104(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f87 + fn parse_rule_2105(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 86i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(86i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f88 + fn parse_rule_2106(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2122i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f89 + fn parse_rule_2107(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 62i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 72i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 86i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | + 123i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | + 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | + 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 199i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 265i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | + 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | + 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | + 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | + 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | + 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | + 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | + 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | + 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | + 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | + 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | + 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | + 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2093i64, &mut branch_matches, &mut has_children); + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(2106i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(199i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + self.parse_child(2103i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(420i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + self.parse_child(3776i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(86i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f90 + fn parse_rule_2108(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f91 + fn parse_rule_2109(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 116i64 | 183i64 | 376i64 | 583i64 | 586i64 | 596i64 | 753i64 | 773i64 | 778i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | + 791i64 | 794i64 | 801i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3849i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f92 + fn parse_rule_2110(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f93 + fn parse_rule_2111(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64 | 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(2109i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f94 + fn parse_rule_2112(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(3776i64, &mut branch_matches, &mut has_children); + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f95 + fn parse_rule_2113(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f96 + fn parse_rule_2114(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(86i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f97 + fn parse_rule_2115(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 453i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(72i64, &mut branch_matches, &mut has_children); + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f98 + fn parse_rule_2116(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64 | 590i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(590i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f99 + fn parse_rule_2117(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 453i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + self.parse_child(3776i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f100 + fn parse_rule_2118(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f101 + fn parse_rule_2119(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f102 + fn parse_rule_2120(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 615i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(615i64, &mut branch_matches, &mut has_children); + self.parse_child(403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // place + fn parse_rule_2121(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 6i64 | 191i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2121i64); + } + self.parse_child(6i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2121i64); + } + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // restrict + fn parse_rule_2122(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 49i64 | 471i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2122i64); + } + self.parse_child(471i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2122i64); + } + self.parse_child(49i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f103 + fn parse_rule_2123(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2551i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f104 + fn parse_rule_2124(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + self.parse_child(2124i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterOrderList + fn parse_rule_2125(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2125i64); + } + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + self.parse_child(2124i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f105 + fn parse_rule_2126(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f106 + fn parse_rule_2127(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterAlgorithmOption + fn parse_rule_2128(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2128i64); + } + self.parse_child(9i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(2129i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f107 + fn parse_rule_2129(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterLockOption + fn parse_rule_2130(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 287i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2130i64); + } + self.parse_child(287i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(2131i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f108 + fn parse_rule_2131(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f109 + fn parse_rule_2132(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2130i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f110 + fn parse_rule_2133(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexLockAndAlgorithm + fn parse_rule_2134(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 287i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2134i64); + } + self.parse_child(2128i64, &mut branch_matches, &mut has_children); + self.parse_child(2132i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2134i64); + } + self.parse_child(2130i64, &mut branch_matches, &mut has_children); + self.parse_child(2133i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // withValidation + fn parse_rule_2135(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2135i64); + } + self.parse_child(2136i64, &mut branch_matches, &mut has_children); + self.parse_child(625i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f111 + fn parse_rule_2136(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(646i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f112 + fn parse_rule_2137(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2136i64, &mut branch_matches, &mut has_children); + self.parse_child(625i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // removePartitioning + fn parse_rule_2138(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 452i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2138i64); + } + self.parse_child(452i64, &mut branch_matches, &mut has_children); + self.parse_child(403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // allOrPartitionNameList + fn parse_rule_2139(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2139i64); + } + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2139i64); + } + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterTablespace + fn parse_rule_2140(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 572i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2140i64); + } + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3793i64, &mut branch_matches, &mut has_children); + self.parse_child(2151i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f113 + fn parse_rule_2141(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 4i64 | 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(4i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(148i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f114 + fn parse_rule_2142(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2164i64, &mut branch_matches, &mut has_children); + self.parse_child(2142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2164i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f115 + fn parse_rule_2143(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 238i64 | 324i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2164i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f116 + fn parse_rule_2144(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2164i64, &mut branch_matches, &mut has_children); + self.parse_child(2142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f117 + fn parse_rule_2145(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 238i64 | 324i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2164i64, &mut branch_matches, &mut has_children); + self.parse_child(2142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f118 + fn parse_rule_2146(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 434i64 | 436i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(434i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(436i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f119 + fn parse_rule_2147(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 55i64 | 371i64 | 434i64 | 436i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(55i64, &mut branch_matches, &mut has_children); + self.parse_child(111i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(2144i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2146i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(371i64, &mut branch_matches, &mut has_children); + self.parse_child(1i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f120 + fn parse_rule_2148(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 55i64 | 371i64 | 434i64 | 436i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2147i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f121 + fn parse_rule_2149(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 158i64 | 163i64 | 238i64 | 324i64 | 374i64 | 553i64 | 638i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2160i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f122 + fn parse_rule_2150(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2160i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f123 + fn parse_rule_2151(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 4i64 | 23i64 | 55i64 | 148i64 | 158i64 | 163i64 | 238i64 | 324i64 | 371i64 | 374i64 | 434i64 | 436i64 | 453i64 | 553i64 | 638i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2141i64, &mut branch_matches, &mut has_children); + self.parse_child(111i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(2150i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2147i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2160i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f124 + fn parse_rule_2152(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterUndoTablespace + fn parse_rule_2153(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2153i64); + } + self.parse_child(605i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3793i64, &mut branch_matches, &mut has_children); + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(2154i64, &mut branch_matches, &mut has_children); + self.parse_child(2152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f125 + fn parse_rule_2154(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 724i64 | 725i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(725i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f126 + fn parse_rule_2155(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2158i64, &mut branch_matches, &mut has_children); + self.parse_child(2155i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2158i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // undoTableSpaceOptions + fn parse_rule_2156(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 553i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2156i64); + } + self.parse_child(2158i64, &mut branch_matches, &mut has_children); + self.parse_child(2155i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f127 + fn parse_rule_2157(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 553i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2158i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // undoTableSpaceOption + fn parse_rule_2158(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 553i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2158i64); + } + self.parse_child(2282i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f128 + fn parse_rule_2159(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2162i64, &mut branch_matches, &mut has_children); + self.parse_child(2159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2162i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterTablespaceOptions + fn parse_rule_2160(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 158i64 | 163i64 | 238i64 | 324i64 | 374i64 | 553i64 | 638i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2160i64); + } + self.parse_child(2162i64, &mut branch_matches, &mut has_children); + self.parse_child(2159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f129 + fn parse_rule_2161(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 158i64 | 163i64 | 238i64 | 324i64 | 374i64 | 553i64 | 638i64 | 750i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2162i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterTablespaceOption + fn parse_rule_2162(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 158i64 | 163i64 | 238i64 | 324i64 | 374i64 | 553i64 | 638i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(238i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(2277i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(2278i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(2282i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(2283i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(2284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2162i64); + } + self.parse_child(2288i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f130 + fn parse_rule_2163(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2283i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // changeTablespaceOption + fn parse_rule_2164(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 238i64 | 324i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2164i64); + } + self.parse_child(238i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2164i64); + } + self.parse_child(2277i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2164i64); + } + self.parse_child(2278i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f131 + fn parse_rule_2165(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2292i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f132 + fn parse_rule_2166(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2294i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterView + fn parse_rule_2167(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 130i64 | 537i64 | 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2167i64); + } + self.parse_child(2165i64, &mut branch_matches, &mut has_children); + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(2166i64, &mut branch_matches, &mut has_children); + self.parse_child(636i64, &mut branch_matches, &mut has_children); + self.parse_child(3790i64, &mut branch_matches, &mut has_children); + self.parse_child(2169i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f133 + fn parse_rule_2168(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3771i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewTail + fn parse_rule_2169(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2169i64); + } + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(2171i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f134 + fn parse_rule_2170(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2173i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewSelect + fn parse_rule_2171(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2171i64); + } + self.parse_child(2201i64, &mut branch_matches, &mut has_children); + self.parse_child(2170i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f135 + fn parse_rule_2172(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2174i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewCheckOption + fn parse_rule_2173(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2173i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(2172i64, &mut branch_matches, &mut has_children); + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f136 + fn parse_rule_2174(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 50i64 | 284i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(50i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createStatement + fn parse_rule_2175(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 97i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2175i64); + } + self.parse_child(97i64, &mut branch_matches, &mut has_children); + self.parse_child(2179i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f137 + fn parse_rule_2176(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 659i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2314i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f138 + fn parse_rule_2177(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 394i64 | 523i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f139 + fn parse_rule_2178(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f140 + fn parse_rule_2179(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 8i64 | 9i64 | 109i64 | 130i64 | 170i64 | 205i64 | 206i64 | 236i64 | 288i64 | 380i64 | 385i64 | 394i64 | 422i64 | 503i64 | 523i64 | 537i64 | 572i64 | 574i64 | + 577i64 | 594i64 | 605i64 | 609i64 | 636i64 | 659i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2182i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2186i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2214i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2207i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2221i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2246i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2290i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2297i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2229i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2252i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2259i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2308i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2314i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f141 + fn parse_rule_2180(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3692i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f142 + fn parse_rule_2181(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2183i64, &mut branch_matches, &mut has_children); + self.parse_child(2181i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2183i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createDatabase + fn parse_rule_2182(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 109i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2182i64); + } + self.parse_child(109i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3780i64, &mut branch_matches, &mut has_children); + self.parse_child(2181i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createDatabaseOption + fn parse_rule_2183(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64 | 69i64 | 128i64 | 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2183i64); + } + self.parse_child(3649i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2183i64); + } + self.parse_child(3647i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2183i64); + } + self.parse_child(3648i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f143 + fn parse_rule_2184(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3648i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f144 + fn parse_rule_2185(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createTable + fn parse_rule_2186(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 574i64 | 577i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2186i64); + } + self.parse_child(2185i64, &mut branch_matches, &mut has_children); + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3802i64, &mut branch_matches, &mut has_children); + self.parse_child(2192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f145 + fn parse_rule_2187(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2194i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f146 + fn parse_rule_2188(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2194i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f147 + fn parse_rule_2189(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3624i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f148 + fn parse_rule_2190(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f149 + fn parse_rule_2191(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2199i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f150 + fn parse_rule_2192(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(275i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(275i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2187i64, &mut branch_matches, &mut has_children); + self.parse_child(2189i64, &mut branch_matches, &mut has_children); + self.parse_child(2190i64, &mut branch_matches, &mut has_children); + self.parse_child(2191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f151 + fn parse_rule_2193(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2196i64, &mut branch_matches, &mut has_children); + self.parse_child(2193i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2196i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableElementList + fn parse_rule_2194(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 62i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 86i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 199i64 | 201i64 | 202i64 | 204i64 | 205i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 265i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | + 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | + 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | + 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | + 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | + 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | + 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 523i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | + 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | + 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 609i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | + 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | + 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | + 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | + 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | + 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | + 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | + 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2194i64); + } + self.parse_child(2196i64, &mut branch_matches, &mut has_children); + self.parse_child(2193i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f152 + fn parse_rule_2195(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2196i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableElement + fn parse_rule_2196(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 62i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 86i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 199i64 | 201i64 | 202i64 | 204i64 | 205i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 265i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | + 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | + 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | + 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | + 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | + 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | + 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 523i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | + 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | + 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 609i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | + 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | + 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | + 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | + 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | + 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | + 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | + 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2196i64); + } + self.parse_child(3513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2196i64); + } + self.parse_child(3519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f153 + fn parse_rule_2197(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2200i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f154 + fn parse_rule_2198(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // duplicateAsQueryExpression + fn parse_rule_2199(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64 | 232i64 | 458i64 | 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2199i64); + } + self.parse_child(2197i64, &mut branch_matches, &mut has_children); + self.parse_child(2198i64, &mut branch_matches, &mut has_children); + self.parse_child(2201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f155 + fn parse_rule_2200(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64 | 458i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(458i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // queryExpressionOrParens + fn parse_rule_2201(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2201i64); + } + self.parse_child(2465i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2201i64); + } + self.parse_child(2483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f156 + fn parse_rule_2202(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createRoutine + fn parse_rule_2203(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 97i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2203i64); + } + self.parse_child(97i64, &mut branch_matches, &mut has_children); + self.parse_child(2204i64, &mut branch_matches, &mut has_children); + self.parse_child(2202i64, &mut branch_matches, &mut has_children); + self.parse_child(-1i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f157 + fn parse_rule_2204(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 8i64 | 130i64 | 206i64 | 422i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2207i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2214i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2221i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f158 + fn parse_rule_2205(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3694i64, &mut branch_matches, &mut has_children); + self.parse_child(2210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f159 + fn parse_rule_2206(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2223i64, &mut branch_matches, &mut has_children); + self.parse_child(2206i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createProcedure + fn parse_rule_2207(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 422i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2207i64); + } + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3782i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2205i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(2206i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f160 + fn parse_rule_2208(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f161 + fn parse_rule_2209(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f162 + fn parse_rule_2210(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3694i64, &mut branch_matches, &mut has_children); + self.parse_child(2210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3694i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f163 + fn parse_rule_2211(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3694i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f164 + fn parse_rule_2212(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 240i64 | 243i64 | 244i64 | 245i64 | 250i64 | 251i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 397i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | + 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | + 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | + 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | + 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | + 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | + 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | + 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | + 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3694i64, &mut branch_matches, &mut has_children); + self.parse_child(2210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f165 + fn parse_rule_2213(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3696i64, &mut branch_matches, &mut has_children); + self.parse_child(2217i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createFunction + fn parse_rule_2214(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 206i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2214i64); + } + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3784i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2213i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(474i64, &mut branch_matches, &mut has_children); + self.parse_child(3698i64, &mut branch_matches, &mut has_children); + self.parse_child(2206i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f166 + fn parse_rule_2215(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f167 + fn parse_rule_2216(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f168 + fn parse_rule_2217(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3696i64, &mut branch_matches, &mut has_children); + self.parse_child(2217i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3696i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f169 + fn parse_rule_2218(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3696i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f170 + fn parse_rule_2219(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3696i64, &mut branch_matches, &mut has_children); + self.parse_child(2217i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f171 + fn parse_rule_2220(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(8i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createUdf + fn parse_rule_2221(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 8i64 | 206i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2221i64); + } + self.parse_child(2220i64, &mut branch_matches, &mut has_children); + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(3798i64, &mut branch_matches, &mut has_children); + self.parse_child(474i64, &mut branch_matches, &mut has_children); + self.parse_child(2222i64, &mut branch_matches, &mut has_children); + self.parse_child(520i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f172 + fn parse_rule_2222(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 126i64 | 249i64 | 437i64 | 556i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(556i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(249i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(437i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(126i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // routineCreateOption + fn parse_rule_2223(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 90i64 | 137i64 | 267i64 | 347i64 | 371i64 | 373i64 | 433i64 | 537i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2223i64); + } + self.parse_child(2226i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2223i64); + } + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(137i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f173 + fn parse_rule_2224(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 90i64 | 137i64 | 267i64 | 347i64 | 371i64 | 373i64 | 433i64 | 537i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2223i64, &mut branch_matches, &mut has_children); + self.parse_child(2224i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // routineAlterOptions + fn parse_rule_2225(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 90i64 | 137i64 | 267i64 | 347i64 | 371i64 | 373i64 | 433i64 | 537i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2225i64); + } + self.parse_child(2224i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // routineOption + fn parse_rule_2226(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 90i64 | 267i64 | 347i64 | 373i64 | 433i64 | 537i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(267i64, &mut branch_matches, &mut has_children); + self.parse_child(537i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(537i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(90i64, &mut branch_matches, &mut has_children); + self.parse_child(537i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(433i64, &mut branch_matches, &mut has_children); + self.parse_child(537i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(347i64, &mut branch_matches, &mut has_children); + self.parse_child(537i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2226i64); + } + self.parse_child(537i64, &mut branch_matches, &mut has_children); + self.parse_child(496i64, &mut branch_matches, &mut has_children); + self.parse_child(2227i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f174 + fn parse_rule_2227(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 250i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(130i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(250i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f175 + fn parse_rule_2228(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2134i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createIndex + fn parse_rule_2229(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 205i64 | 236i64 | 380i64 | 385i64 | 523i64 | 609i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2229i64); + } + self.parse_child(2057i64, &mut branch_matches, &mut has_children); + self.parse_child(2238i64, &mut branch_matches, &mut has_children); + self.parse_child(2228i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f176 + fn parse_rule_2230(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f177 + fn parse_rule_2231(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + self.parse_child(2230i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f178 + fn parse_rule_2232(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2241i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f179 + fn parse_rule_2233(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + self.parse_child(2230i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f180 + fn parse_rule_2234(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(609i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f181 + fn parse_rule_2235(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3579i64, &mut branch_matches, &mut has_children); + self.parse_child(2235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3579i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f182 + fn parse_rule_2236(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3585i64, &mut branch_matches, &mut has_children); + self.parse_child(2236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3585i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f183 + fn parse_rule_2237(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3586i64, &mut branch_matches, &mut has_children); + self.parse_child(2237i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f184 + fn parse_rule_2238(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 205i64 | 236i64 | 523i64 | 609i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2234i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(2233i64, &mut branch_matches, &mut has_children); + self.parse_child(2244i64, &mut branch_matches, &mut has_children); + self.parse_child(2235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(205i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + self.parse_child(2244i64, &mut branch_matches, &mut has_children); + self.parse_child(2236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(523i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + self.parse_child(2244i64, &mut branch_matches, &mut has_children); + self.parse_child(2237i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f185 + fn parse_rule_2239(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f186 + fn parse_rule_2240(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2242i64, &mut branch_matches, &mut has_children); + self.parse_child(3577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexNameAndType + fn parse_rule_2241(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2241i64); + } + self.parse_child(2239i64, &mut branch_matches, &mut has_children); + self.parse_child(2240i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f187 + fn parse_rule_2242(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 599i64 | 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(599i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f188 + fn parse_rule_2243(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 599i64 | 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2242i64, &mut branch_matches, &mut has_children); + self.parse_child(3577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createIndexTarget + fn parse_rule_2244(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2244i64); + } + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f189 + fn parse_rule_2245(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2249i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createLogfileGroup + fn parse_rule_2246(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 288i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2246i64); + } + self.parse_child(288i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3794i64, &mut branch_matches, &mut has_children); + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(2247i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(2245i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f190 + fn parse_rule_2247(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 440i64 | 603i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(603i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(440i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f191 + fn parse_rule_2248(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2251i64, &mut branch_matches, &mut has_children); + self.parse_child(2248i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2251i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // logfileGroupOptions + fn parse_rule_2249(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 163i64 | 238i64 | 368i64 | 374i64 | 441i64 | 553i64 | 604i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2249i64); + } + self.parse_child(2251i64, &mut branch_matches, &mut has_children); + self.parse_child(2248i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f192 + fn parse_rule_2250(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 163i64 | 238i64 | 368i64 | 374i64 | 441i64 | 553i64 | 604i64 | 638i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2251i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // logfileGroupOption + fn parse_rule_2251(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 163i64 | 238i64 | 368i64 | 374i64 | 441i64 | 553i64 | 604i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2251i64); + } + self.parse_child(2274i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2251i64); + } + self.parse_child(2275i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2251i64); + } + self.parse_child(2280i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2251i64); + } + self.parse_child(2282i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2251i64); + } + self.parse_child(2284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2251i64); + } + self.parse_child(2286i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createServer + fn parse_rule_2252(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 503i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2252i64); + } + self.parse_child(503i64, &mut branch_matches, &mut has_children); + self.parse_child(3799i64, &mut branch_matches, &mut has_children); + self.parse_child(199i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(648i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + self.parse_child(2254i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f193 + fn parse_rule_2253(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2256i64, &mut branch_matches, &mut has_children); + self.parse_child(2253i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2256i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // serverOptions + fn parse_rule_2254(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 390i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2254i64); + } + self.parse_child(390i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2256i64, &mut branch_matches, &mut has_children); + self.parse_child(2253i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f194 + fn parse_rule_2255(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2256i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // serverOption + fn parse_rule_2256(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 109i64 | 224i64 | 398i64 | 406i64 | 413i64 | 519i64 | 618i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(224i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(109i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(519i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(398i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2256i64); + } + self.parse_child(413i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f195 + fn parse_rule_2257(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(620i64, &mut branch_matches, &mut has_children); + self.parse_child(288i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3795i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f196 + fn parse_rule_2258(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2268i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createTablespace + fn parse_rule_2259(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 572i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2259i64); + } + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3792i64, &mut branch_matches, &mut has_children); + self.parse_child(2262i64, &mut branch_matches, &mut has_children); + self.parse_child(2257i64, &mut branch_matches, &mut has_children); + self.parse_child(2258i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f197 + fn parse_rule_2260(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 620i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(620i64, &mut branch_matches, &mut has_children); + self.parse_child(288i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3795i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createUndoTablespace + fn parse_rule_2261(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2261i64); + } + self.parse_child(605i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3792i64, &mut branch_matches, &mut has_children); + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(2266i64, &mut branch_matches, &mut has_children); + self.parse_child(2152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsDataFileName + fn parse_rule_2262(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2262i64); + } + self.parse_child(2263i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2262i64); + } + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(2266i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f198 + fn parse_rule_2263(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(2266i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f199 + fn parse_rule_2264(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 4i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(4i64, &mut branch_matches, &mut has_children); + self.parse_child(2266i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f200 + fn parse_rule_2265(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2263i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsDataFile + fn parse_rule_2266(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 111i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2266i64); + } + self.parse_child(111i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f201 + fn parse_rule_2267(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2270i64, &mut branch_matches, &mut has_children); + self.parse_child(2267i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tablespaceOptions + fn parse_rule_2268(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 75i64 | 158i64 | 163i64 | 181i64 | 189i64 | 238i64 | 324i64 | 368i64 | 374i64 | 553i64 | 638i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2268i64); + } + self.parse_child(2270i64, &mut branch_matches, &mut has_children); + self.parse_child(2267i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f202 + fn parse_rule_2269(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 75i64 | 158i64 | 163i64 | 181i64 | 189i64 | 238i64 | 324i64 | 368i64 | 374i64 | 553i64 | 638i64 | 750i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tablespaceOption + fn parse_rule_2270(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64 | 75i64 | 158i64 | 163i64 | 181i64 | 189i64 | 238i64 | 324i64 | 368i64 | 374i64 | 553i64 | 638i64 | 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2274i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2277i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2278i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2279i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2280i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2282i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2283i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2286i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2287i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2270i64); + } + self.parse_child(2288i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f203 + fn parse_rule_2271(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2283i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f204 + fn parse_rule_2272(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 189i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2287i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f205 + fn parse_rule_2273(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2288i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionInitialSize + fn parse_rule_2274(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 238i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2274i64); + } + self.parse_child(238i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionUndoRedoBufferSize + fn parse_rule_2275(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 441i64 | 604i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2275i64); + } + self.parse_child(2276i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f206 + fn parse_rule_2276(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 441i64 | 604i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(604i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(441i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionAutoextendSize + fn parse_rule_2277(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2277i64); + } + self.parse_child(23i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionMaxSize + fn parse_rule_2278(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 324i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2278i64); + } + self.parse_child(324i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionExtentSize + fn parse_rule_2279(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 181i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2279i64); + } + self.parse_child(181i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionNodegroup + fn parse_rule_2280(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 368i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2280i64); + } + self.parse_child(368i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f207 + fn parse_rule_2281(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(553i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionEngine + fn parse_rule_2282(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 553i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2282i64); + } + self.parse_child(2281i64, &mut branch_matches, &mut has_children); + self.parse_child(163i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3801i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionEngineAttribute + fn parse_rule_2283(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2283i64); + } + self.parse_child(848i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionWait + fn parse_rule_2284(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 374i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2284i64); + } + self.parse_child(2285i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f208 + fn parse_rule_2285(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 374i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(638i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(374i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionComment + fn parse_rule_2286(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2286i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionFileblockSize + fn parse_rule_2287(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 189i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2287i64); + } + self.parse_child(189i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3875i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tsOptionEncryption + fn parse_rule_2288(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2288i64); + } + self.parse_child(158i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f209 + fn parse_rule_2289(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2291i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createView + fn parse_rule_2290(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 130i64 | 394i64 | 537i64 | 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2290i64); + } + self.parse_child(2289i64, &mut branch_matches, &mut has_children); + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(2166i64, &mut branch_matches, &mut has_children); + self.parse_child(636i64, &mut branch_matches, &mut has_children); + self.parse_child(3788i64, &mut branch_matches, &mut has_children); + self.parse_child(2169i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewReplaceOrAlgorithm + fn parse_rule_2291(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64 | 394i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2291i64); + } + self.parse_child(394i64, &mut branch_matches, &mut has_children); + self.parse_child(458i64, &mut branch_matches, &mut has_children); + self.parse_child(2165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2291i64); + } + self.parse_child(2292i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewAlgorithm + fn parse_rule_2292(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2292i64); + } + self.parse_child(9i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2293i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f210 + fn parse_rule_2293(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 335i64 | 578i64 | 602i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(602i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(335i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(578i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewSuid + fn parse_rule_2294(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 537i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2294i64); + } + self.parse_child(537i64, &mut branch_matches, &mut has_children); + self.parse_child(496i64, &mut branch_matches, &mut has_children); + self.parse_child(2295i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f211 + fn parse_rule_2295(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 250i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(130i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(250i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f212 + fn parse_rule_2296(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2302i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createTrigger + fn parse_rule_2297(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 594i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2297i64); + } + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(594i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3786i64, &mut branch_matches, &mut has_children); + self.parse_child(2300i64, &mut branch_matches, &mut has_children); + self.parse_child(2301i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(153i64, &mut branch_matches, &mut has_children); + self.parse_child(487i64, &mut branch_matches, &mut has_children); + self.parse_child(2296i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f213 + fn parse_rule_2298(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f214 + fn parse_rule_2299(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f215 + fn parse_rule_2300(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 6i64 | 28i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(28i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(6i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f216 + fn parse_rule_2301(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 133i64 | 242i64 | 614i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(614i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(133i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // triggerFollowsPrecedesClause + fn parse_rule_2302(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 197i64 | 415i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2302i64); + } + self.parse_child(2303i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f217 + fn parse_rule_2303(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 197i64 | 415i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(197i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(415i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f218 + fn parse_rule_2304(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 197i64 | 415i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2303i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f219 + fn parse_rule_2305(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(79i64, &mut branch_matches, &mut has_children); + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f220 + fn parse_rule_2306(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2312i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f221 + fn parse_rule_2307(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createEvent + fn parse_rule_2308(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64 | 170i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2308i64); + } + self.parse_child(2032i64, &mut branch_matches, &mut has_children); + self.parse_child(170i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3796i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(490i64, &mut branch_matches, &mut has_children); + self.parse_child(3510i64, &mut branch_matches, &mut has_children); + self.parse_child(2305i64, &mut branch_matches, &mut has_children); + self.parse_child(2306i64, &mut branch_matches, &mut has_children); + self.parse_child(2307i64, &mut branch_matches, &mut has_children); + self.parse_child(147i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f222 + fn parse_rule_2309(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(79i64, &mut branch_matches, &mut has_children); + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f223 + fn parse_rule_2310(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f224 + fn parse_rule_2311(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f225 + fn parse_rule_2312(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 140i64 | 156i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(140i64, &mut branch_matches, &mut has_children); + self.parse_child(2310i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f226 + fn parse_rule_2313(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createRole + fn parse_rule_2314(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 659i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2314i64); + } + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f227 + fn parse_rule_2315(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2317i64, &mut branch_matches, &mut has_children); + self.parse_child(2315i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2317i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createSpatialReference + fn parse_rule_2316(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 394i64 | 523i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2316i64); + } + self.parse_child(394i64, &mut branch_matches, &mut has_children); + self.parse_child(458i64, &mut branch_matches, &mut has_children); + self.parse_child(523i64, &mut branch_matches, &mut has_children); + self.parse_child(718i64, &mut branch_matches, &mut has_children); + self.parse_child(710i64, &mut branch_matches, &mut has_children); + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + self.parse_child(2315i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2316i64); + } + self.parse_child(523i64, &mut branch_matches, &mut has_children); + self.parse_child(718i64, &mut branch_matches, &mut has_children); + self.parse_child(710i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + self.parse_child(2315i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // srsAttribute + fn parse_rule_2317(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 357i64 | 715i64 | 716i64 | 717i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2317i64); + } + self.parse_child(357i64, &mut branch_matches, &mut has_children); + self.parse_child(580i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2317i64); + } + self.parse_child(715i64, &mut branch_matches, &mut has_children); + self.parse_child(580i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2317i64); + } + self.parse_child(717i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2317i64); + } + self.parse_child(716i64, &mut branch_matches, &mut has_children); + self.parse_child(580i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropStatement + fn parse_rule_2318(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2318i64); + } + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(2322i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f228 + fn parse_rule_2319(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 659i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2349i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f229 + fn parse_rule_2320(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 523i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2350i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f230 + fn parse_rule_2321(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2351i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f231 + fn parse_rule_2322(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 109i64 | 170i64 | 206i64 | 236i64 | 288i64 | 380i64 | 385i64 | 422i64 | 503i64 | 523i64 | 571i64 | 572i64 | 574i64 | 577i64 | 594i64 | 605i64 | 636i64 | 659i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2324i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2325i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2327i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2328i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2330i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2335i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2337i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2341i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2345i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2347i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2349i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2350i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2351i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f232 + fn parse_rule_2323(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropDatabase + fn parse_rule_2324(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 109i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2324i64); + } + self.parse_child(109i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropEvent + fn parse_rule_2325(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 170i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2325i64); + } + self.parse_child(170i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3797i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropFunction + fn parse_rule_2326(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 206i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2326i64); + } + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3785i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropProcedure + fn parse_rule_2327(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 422i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2327i64); + } + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropIndex + fn parse_rule_2328(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 236i64 | 380i64 | 385i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2328i64); + } + self.parse_child(2057i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(3776i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2228i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f233 + fn parse_rule_2329(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + self.parse_child(2331i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropLogfileGroup + fn parse_rule_2330(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 288i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2330i64); + } + self.parse_child(288i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3795i64, &mut branch_matches, &mut has_children); + self.parse_child(2329i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f234 + fn parse_rule_2331(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + self.parse_child(2331i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f235 + fn parse_rule_2332(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 374i64 | 553i64 | 638i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f236 + fn parse_rule_2333(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 374i64 | 553i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + self.parse_child(2331i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropLogfileGroupOption + fn parse_rule_2334(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 374i64 | 553i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2334i64); + } + self.parse_child(2284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2334i64); + } + self.parse_child(2282i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropServer + fn parse_rule_2335(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 503i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2335i64); + } + self.parse_child(503i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3800i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f237 + fn parse_rule_2336(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2339i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropTable + fn parse_rule_2337(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64 | 577i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2337i64); + } + self.parse_child(2185i64, &mut branch_matches, &mut has_children); + self.parse_child(2338i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + self.parse_child(2336i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f238 + fn parse_rule_2338(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f239 + fn parse_rule_2339(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 49i64 | 471i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(471i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(49i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f240 + fn parse_rule_2340(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + self.parse_child(2342i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropTableSpace + fn parse_rule_2341(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 572i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2341i64); + } + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3793i64, &mut branch_matches, &mut has_children); + self.parse_child(2340i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f241 + fn parse_rule_2342(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + self.parse_child(2342i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f242 + fn parse_rule_2343(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 374i64 | 553i64 | 638i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f243 + fn parse_rule_2344(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 163i64 | 374i64 | 553i64 | 638i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2334i64, &mut branch_matches, &mut has_children); + self.parse_child(2342i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropTrigger + fn parse_rule_2345(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 594i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2345i64); + } + self.parse_child(594i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f244 + fn parse_rule_2346(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2348i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropView + fn parse_rule_2347(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2347i64); + } + self.parse_child(636i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3701i64, &mut branch_matches, &mut has_children); + self.parse_child(2346i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f245 + fn parse_rule_2348(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 49i64 | 471i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(471i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(49i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropRole + fn parse_rule_2349(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 659i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2349i64); + } + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropSpatialReference + fn parse_rule_2350(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 523i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2350i64); + } + self.parse_child(523i64, &mut branch_matches, &mut has_children); + self.parse_child(718i64, &mut branch_matches, &mut has_children); + self.parse_child(710i64, &mut branch_matches, &mut has_children); + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropUndoTablespace + fn parse_rule_2351(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2351i64); + } + self.parse_child(605i64, &mut branch_matches, &mut has_children); + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3793i64, &mut branch_matches, &mut has_children); + self.parse_child(2152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f246 + fn parse_rule_2352(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2356i64, &mut branch_matches, &mut has_children); + self.parse_child(2352i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // renameTableStatement + fn parse_rule_2353(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 453i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2353i64); + } + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(2354i64, &mut branch_matches, &mut has_children); + self.parse_child(2356i64, &mut branch_matches, &mut has_children); + self.parse_child(2352i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f247 + fn parse_rule_2354(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f248 + fn parse_rule_2355(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // renamePair + fn parse_rule_2356(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2356i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3802i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f249 + fn parse_rule_2357(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // truncateTableStatement + fn parse_rule_2358(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 597i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2358i64); + } + self.parse_child(597i64, &mut branch_matches, &mut has_children); + self.parse_child(2357i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // importStatement + fn parse_rule_2359(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 234i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2359i64); + } + self.parse_child(234i64, &mut branch_matches, &mut has_children); + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3863i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f250 + fn parse_rule_2360(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2362i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // callStatement + fn parse_rule_2361(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 48i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2361i64); + } + self.parse_child(48i64, &mut branch_matches, &mut has_children); + self.parse_child(3783i64, &mut branch_matches, &mut has_children); + self.parse_child(2360i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f251 + fn parse_rule_2362(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f252 + fn parse_rule_2363(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2362i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f253 + fn parse_rule_2364(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f254 + fn parse_rule_2365(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2380i64, &mut branch_matches, &mut has_children); + self.parse_child(2365i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2380i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // deleteStatement + fn parse_rule_2366(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 133i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2366i64); + } + self.parse_child(2364i64, &mut branch_matches, &mut has_children); + self.parse_child(133i64, &mut branch_matches, &mut has_children); + self.parse_child(2365i64, &mut branch_matches, &mut has_children); + self.parse_child(2377i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f255 + fn parse_rule_2367(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f256 + fn parse_rule_2368(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f257 + fn parse_rule_2369(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 17i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 763i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f258 + fn parse_rule_2370(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f259 + fn parse_rule_2371(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 17i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 763i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f260 + fn parse_rule_2372(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2585i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f261 + fn parse_rule_2373(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2378i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f262 + fn parse_rule_2374(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2550i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f263 + fn parse_rule_2375(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2499i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f264 + fn parse_rule_2376(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3816i64, &mut branch_matches, &mut has_children); + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(2555i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2370i64, &mut branch_matches, &mut has_children); + self.parse_child(2373i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2375i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f265 + fn parse_rule_2377(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 203i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(2376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3816i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(2555i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionDelete + fn parse_rule_2378(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2378i64); + } + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f266 + fn parse_rule_2379(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // deleteStatementOption + fn parse_rule_2380(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64 | 295i64 | 431i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2380i64); + } + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2380i64); + } + self.parse_child(295i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2380i64); + } + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2380i64); + } + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // doStatement + fn parse_rule_2381(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 147i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2381i64); + } + self.parse_child(147i64, &mut branch_matches, &mut has_children); + self.parse_child(2384i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f267 + fn parse_rule_2382(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 775i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | + 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2578i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f268 + fn parse_rule_2383(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f269 + fn parse_rule_2384(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 775i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | + 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2578i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // handlerStatement + fn parse_rule_2385(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 219i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2385i64); + } + self.parse_child(219i64, &mut branch_matches, &mut has_children); + self.parse_child(2389i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f270 + fn parse_rule_2386(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2498i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f271 + fn parse_rule_2387(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 66i64 | 435i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(66i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(2390i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f272 + fn parse_rule_2388(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f273 + fn parse_rule_2389(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(387i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2387i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // handlerReadOrScan + fn parse_rule_2390(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2390i64); + } + self.parse_child(2391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2390i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f274 + fn parse_rule_2391(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 191i64 | 367i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(367i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f275 + fn parse_rule_2392(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 191i64 | 268i64 | 367i64 | 419i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(367i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(419i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(268i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f276 + fn parse_rule_2393(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 763i64 | 764i64 | 765i64 | 768i64 | 769i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(769i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(768i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(764i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f277 + fn parse_rule_2394(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 191i64 | 268i64 | 367i64 | 419i64 | 763i64 | 764i64 | 765i64 | 768i64 | 769i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2392i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2393i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2424i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f278 + fn parse_rule_2395(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2408i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f279 + fn parse_rule_2396(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f280 + fn parse_rule_2397(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(248i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f281 + fn parse_rule_2398(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f282 + fn parse_rule_2399(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2429i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertStatement + fn parse_rule_2400(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 242i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2400i64); + } + self.parse_child(242i64, &mut branch_matches, &mut has_children); + self.parse_child(2395i64, &mut branch_matches, &mut has_children); + self.parse_child(2396i64, &mut branch_matches, &mut has_children); + self.parse_child(2397i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2398i64, &mut branch_matches, &mut has_children); + self.parse_child(2407i64, &mut branch_matches, &mut has_children); + self.parse_child(2399i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f283 + fn parse_rule_2401(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f284 + fn parse_rule_2402(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f285 + fn parse_rule_2403(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f286 + fn parse_rule_2404(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f287 + fn parse_rule_2405(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f288 + fn parse_rule_2406(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f289 + fn parse_rule_2407(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 506i64 | 574i64 | 626i64 | 627i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2410i64, &mut branch_matches, &mut has_children); + self.parse_child(2402i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3704i64, &mut branch_matches, &mut has_children); + self.parse_child(2405i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertLockOption + fn parse_rule_2408(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 131i64 | 223i64 | 295i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2408i64); + } + self.parse_child(295i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2408i64); + } + self.parse_child(131i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2408i64); + } + self.parse_child(223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f290 + fn parse_rule_2409(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2411i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertFromConstructor + fn parse_rule_2410(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 626i64 | 627i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2410i64); + } + self.parse_child(2409i64, &mut branch_matches, &mut has_children); + self.parse_child(2416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f291 + fn parse_rule_2411(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2414i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f292 + fn parse_rule_2412(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2411i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f293 + fn parse_rule_2413(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3774i64, &mut branch_matches, &mut has_children); + self.parse_child(2413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3774i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fields + fn parse_rule_2414(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2414i64); + } + self.parse_child(3774i64, &mut branch_matches, &mut has_children); + self.parse_child(2413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f294 + fn parse_rule_2415(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3774i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertValues + fn parse_rule_2416(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 626i64 | 627i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2416i64); + } + self.parse_child(2417i64, &mut branch_matches, &mut has_children); + self.parse_child(2421i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f295 + fn parse_rule_2417(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 626i64 | 627i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(626i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertQueryExpression + fn parse_rule_2418(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2418i64); + } + self.parse_child(2201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2418i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2411i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(2201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f296 + fn parse_rule_2419(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2424i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f297 + fn parse_rule_2420(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2419i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(2420i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2419i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // valueList + fn parse_rule_2421(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2421i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2419i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(2420i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f298 + fn parse_rule_2422(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2419i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f299 + fn parse_rule_2423(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2426i64, &mut branch_matches, &mut has_children); + self.parse_child(2423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2426i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // values + fn parse_rule_2424(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2424i64); + } + self.parse_child(2425i64, &mut branch_matches, &mut has_children); + self.parse_child(2423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f300 + fn parse_rule_2425(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f301 + fn parse_rule_2426(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f302 + fn parse_rule_2427(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2426i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // valuesReference + fn parse_rule_2428(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2428i64); + } + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertUpdateList + fn parse_rule_2429(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2429i64); + } + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(151i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(3704i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f303 + fn parse_rule_2430(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2438i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f304 + fn parse_rule_2431(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f305 + fn parse_rule_2432(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2439i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f306 + fn parse_rule_2433(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3708i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f307 + fn parse_rule_2434(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2441i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f308 + fn parse_rule_2435(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3710i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f309 + fn parse_rule_2436(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3714i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // loadStatement + fn parse_rule_2437(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 281i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2437i64); + } + self.parse_child(281i64, &mut branch_matches, &mut has_children); + self.parse_child(2440i64, &mut branch_matches, &mut has_children); + self.parse_child(2430i64, &mut branch_matches, &mut has_children); + self.parse_child(2431i64, &mut branch_matches, &mut has_children); + self.parse_child(237i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(2432i64, &mut branch_matches, &mut has_children); + self.parse_child(248i64, &mut branch_matches, &mut has_children); + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2398i64, &mut branch_matches, &mut has_children); + self.parse_child(2433i64, &mut branch_matches, &mut has_children); + self.parse_child(2434i64, &mut branch_matches, &mut has_children); + self.parse_child(2435i64, &mut branch_matches, &mut has_children); + self.parse_child(2436i64, &mut branch_matches, &mut has_children); + self.parse_child(2445i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f310 + fn parse_rule_2438(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 82i64 | 295i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(295i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(82i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f311 + fn parse_rule_2439(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64 | 458i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(458i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dataOrXml + fn parse_rule_2440(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 112i64 | 653i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2440i64); + } + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2440i64); + } + self.parse_child(653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // xmlRowsIdentifiedBy + fn parse_rule_2441(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 484i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2441i64); + } + self.parse_child(484i64, &mut branch_matches, &mut has_children); + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f312 + fn parse_rule_2442(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(2446i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f313 + fn parse_rule_2443(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2450i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f314 + fn parse_rule_2444(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3704i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // loadDataFileTail + fn parse_rule_2445(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2445i64); + } + self.parse_child(2442i64, &mut branch_matches, &mut has_children); + self.parse_child(2443i64, &mut branch_matches, &mut has_children); + self.parse_child(2444i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f315 + fn parse_rule_2446(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 278i64 | 484i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(278i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f316 + fn parse_rule_2447(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(2446i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f317 + fn parse_rule_2448(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3704i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f318 + fn parse_rule_2449(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2452i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // loadDataFileTargetList + fn parse_rule_2450(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2450i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2449i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f319 + fn parse_rule_2451(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2454i64, &mut branch_matches, &mut has_children); + self.parse_child(2451i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2454i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldOrVariableList + fn parse_rule_2452(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 751i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2452i64); + } + self.parse_child(2453i64, &mut branch_matches, &mut has_children); + self.parse_child(2451i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f320 + fn parse_rule_2453(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 751i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f321 + fn parse_rule_2454(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 751i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f322 + fn parse_rule_2455(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2454i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f323 + fn parse_rule_2456(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2458i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // replaceStatement + fn parse_rule_2457(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 458i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2457i64); + } + self.parse_child(458i64, &mut branch_matches, &mut has_children); + self.parse_child(2456i64, &mut branch_matches, &mut has_children); + self.parse_child(2397i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2398i64, &mut branch_matches, &mut has_children); + self.parse_child(2459i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f324 + fn parse_rule_2458(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 131i64 | 295i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(295i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(131i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f325 + fn parse_rule_2459(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 506i64 | 574i64 | 626i64 | 627i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2410i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3704i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f326 + fn parse_rule_2460(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2566i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // selectStatement + fn parse_rule_2461(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2461i64); + } + self.parse_child(2465i64, &mut branch_matches, &mut has_children); + self.parse_child(2460i64, &mut branch_matches, &mut has_children); + if branch_matches && self.current_token_id() == lex::INTO_SYMBOL { + branch_matches = false; + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2461i64); + } + self.parse_child(2462i64, &mut branch_matches, &mut has_children); + if branch_matches && self.current_token_id() == lex::INTO_SYMBOL { + branch_matches = false; + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // selectStatementWithInto + fn parse_rule_2462(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2462i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2462i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2462i64); + } + self.parse_child(2465i64, &mut branch_matches, &mut has_children); + self.parse_child(2506i64, &mut branch_matches, &mut has_children); + self.parse_child(2460i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2462i64); + } + self.parse_child(2465i64, &mut branch_matches, &mut has_children); + self.parse_child(2566i64, &mut branch_matches, &mut has_children); + self.parse_child(2506i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f327 + fn parse_rule_2463(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f328 + fn parse_rule_2464(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // queryExpression + fn parse_rule_2465(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2465i64); + } + self.parse_child(2463i64, &mut branch_matches, &mut has_children); + self.parse_child(2468i64, &mut branch_matches, &mut has_children); + self.parse_child(2464i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f329 + fn parse_rule_2466(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f330 + fn parse_rule_2467(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f331 + fn parse_rule_2468(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2472i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2483i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f332 + fn parse_rule_2469(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 422i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f333 + fn parse_rule_2470(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 422i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f334 + fn parse_rule_2471(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2474i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2478i64, &mut branch_matches, &mut has_children); + self.parse_child(2471i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2474i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2478i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // queryExpressionBody + fn parse_rule_2472(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2472i64); + } + self.parse_child(2478i64, &mut branch_matches, &mut has_children); + self.parse_child(2471i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f335 + fn parse_rule_2473(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 663i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(663i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f336 + fn parse_rule_2474(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 608i64 | 663i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(608i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(663i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f337 + fn parse_rule_2475(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2634i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f338 + fn parse_rule_2476(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 608i64 | 663i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2474i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2478i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f339 + fn parse_rule_2477(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(811i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2480i64, &mut branch_matches, &mut has_children); + self.parse_child(2477i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(811i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2480i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // queryTerm + fn parse_rule_2478(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2478i64); + } + self.parse_child(2479i64, &mut branch_matches, &mut has_children); + self.parse_child(2477i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f340 + fn parse_rule_2479(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f341 + fn parse_rule_2480(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f342 + fn parse_rule_2481(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 811i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(811i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2480i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f343 + fn parse_rule_2482(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 811i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(811i64, &mut branch_matches, &mut has_children); + self.parse_child(2475i64, &mut branch_matches, &mut has_children); + self.parse_child(2480i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // queryExpressionParens + fn parse_rule_2483(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2483i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2465i64, &mut branch_matches, &mut has_children); + self.parse_child(2460i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // queryPrimary + fn parse_rule_2484(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64 | 574i64 | 626i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2484i64); + } + self.parse_child(2493i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2484i64); + } + self.parse_child(2558i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2484i64); + } + self.parse_child(2560i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f344 + fn parse_rule_2485(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 626i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2558i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f345 + fn parse_rule_2486(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2560i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f346 + fn parse_rule_2487(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2562i64, &mut branch_matches, &mut has_children); + self.parse_child(2487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2562i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f347 + fn parse_rule_2488(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2506i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f348 + fn parse_rule_2489(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2552i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f349 + fn parse_rule_2490(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f350 + fn parse_rule_2491(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f351 + fn parse_rule_2492(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // querySpecification + fn parse_rule_2493(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 497i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2493i64); + } + self.parse_child(497i64, &mut branch_matches, &mut has_children); + self.parse_child(2487i64, &mut branch_matches, &mut has_children); + self.parse_child(2578i64, &mut branch_matches, &mut has_children); + self.parse_child(2488i64, &mut branch_matches, &mut has_children); + self.parse_child(2489i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + self.parse_child(2490i64, &mut branch_matches, &mut has_children); + self.parse_child(2491i64, &mut branch_matches, &mut has_children); + self.parse_child(2492i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f352 + fn parse_rule_2494(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 699i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f353 + fn parse_rule_2495(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 699i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // subquery + fn parse_rule_2496(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2496i64); + } + self.parse_child(2483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // querySpecOption + fn parse_rule_2497(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 143i64 | 223i64 | 531i64 | 532i64 | 534i64 | 536i64 | 555i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(143i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(555i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(536i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(531i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(532i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2497i64); + } + self.parse_child(534i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // limitClause + fn parse_rule_2498(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 276i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2498i64); + } + self.parse_child(276i64, &mut branch_matches, &mut has_children); + self.parse_child(2501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // simpleLimitClause + fn parse_rule_2499(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 276i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2499i64); + } + self.parse_child(276i64, &mut branch_matches, &mut has_children); + self.parse_child(2504i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f354 + fn parse_rule_2500(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2502i64, &mut branch_matches, &mut has_children); + self.parse_child(2504i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // limitOptions + fn parse_rule_2501(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 754i64 | 781i64 | 784i64 | 787i64 | 788i64 | 791i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2501i64); + } + self.parse_child(2504i64, &mut branch_matches, &mut has_children); + self.parse_child(2500i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f355 + fn parse_rule_2502(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 381i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(381i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f356 + fn parse_rule_2503(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 381i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2502i64, &mut branch_matches, &mut has_children); + self.parse_child(2504i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // limitOption + fn parse_rule_2504(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 754i64 | 781i64 | 784i64 | 787i64 | 788i64 | 791i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2504i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2504i64); + } + self.parse_child(2505i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f357 + fn parse_rule_2505(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 754i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(754i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(791i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // intoClause + fn parse_rule_2506(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 248i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2506i64); + } + self.parse_child(248i64, &mut branch_matches, &mut has_children); + self.parse_child(2511i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f358 + fn parse_rule_2507(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 781i64 | 784i64 | 790i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f359 + fn parse_rule_2508(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 781i64 | 784i64 | 790i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f360 + fn parse_rule_2509(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2508i64, &mut branch_matches, &mut has_children); + self.parse_child(2509i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2508i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f361 + fn parse_rule_2510(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2508i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f362 + fn parse_rule_2511(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 396i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 781i64 | 784i64 | 790i64 | 792i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(396i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2433i64, &mut branch_matches, &mut has_children); + self.parse_child(2435i64, &mut branch_matches, &mut has_children); + self.parse_child(2436i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(150i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2507i64, &mut branch_matches, &mut has_children); + self.parse_child(2509i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f363 + fn parse_rule_2512(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(2514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // procedureAnalyseClause + fn parse_rule_2513(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 422i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2513i64); + } + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(13i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2512i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f364 + fn parse_rule_2514(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f365 + fn parse_rule_2515(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f366 + fn parse_rule_2516(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 787i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(2514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // havingClause + fn parse_rule_2517(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 221i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2517i64); + } + self.parse_child(221i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f367 + fn parse_rule_2518(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2521i64, &mut branch_matches, &mut has_children); + self.parse_child(2518i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2521i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowClause + fn parse_rule_2519(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 699i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2519i64); + } + self.parse_child(699i64, &mut branch_matches, &mut has_children); + self.parse_child(2521i64, &mut branch_matches, &mut has_children); + self.parse_child(2518i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f368 + fn parse_rule_2520(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2521i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowDefinition + fn parse_rule_2521(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2521i64); + } + self.parse_child(3826i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(2522i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowSpec + fn parse_rule_2522(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2522i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2528i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f369 + fn parse_rule_2523(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f370 + fn parse_rule_2524(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f371 + fn parse_rule_2525(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f372 + fn parse_rule_2526(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3826i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f373 + fn parse_rule_2527(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowSpecDetails + fn parse_rule_2528(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2528i64); + } + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2523i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2528i64); + } + self.parse_child(2524i64, &mut branch_matches, &mut has_children); + self.parse_child(2550i64, &mut branch_matches, &mut has_children); + self.parse_child(2523i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2528i64); + } + self.parse_child(2525i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2528i64); + } + self.parse_child(2526i64, &mut branch_matches, &mut has_children); + self.parse_child(2527i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2523i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f374 + fn parse_rule_2529(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f375 + fn parse_rule_2530(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f376 + fn parse_rule_2531(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f377 + fn parse_rule_2532(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2539i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameClause + fn parse_rule_2533(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 432i64 | 484i64 | 683i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2533i64); + } + self.parse_child(2534i64, &mut branch_matches, &mut has_children); + self.parse_child(2535i64, &mut branch_matches, &mut has_children); + self.parse_child(2532i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameUnits + fn parse_rule_2534(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 432i64 | 484i64 | 683i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2534i64); + } + self.parse_child(484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2534i64); + } + self.parse_child(432i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2534i64); + } + self.parse_child(683i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameExtent + fn parse_rule_2535(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 30i64 | 101i64 | 247i64 | 698i64 | 754i64 | 783i64 | 785i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2535i64); + } + self.parse_child(2536i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2535i64); + } + self.parse_child(2537i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameStart + fn parse_rule_2536(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 101i64 | 247i64 | 698i64 | 754i64 | 783i64 | 785i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2536i64); + } + self.parse_child(698i64, &mut branch_matches, &mut has_children); + self.parse_child(693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2536i64); + } + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + self.parse_child(693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2536i64); + } + self.parse_child(754i64, &mut branch_matches, &mut has_children); + self.parse_child(693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2536i64); + } + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + self.parse_child(693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2536i64); + } + self.parse_child(101i64, &mut branch_matches, &mut has_children); + self.parse_child(487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameBetween + fn parse_rule_2537(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 30i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2537i64); + } + self.parse_child(30i64, &mut branch_matches, &mut has_children); + self.parse_child(2538i64, &mut branch_matches, &mut has_children); + self.parse_child(15i64, &mut branch_matches, &mut has_children); + self.parse_child(2538i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameBound + fn parse_rule_2538(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 101i64 | 247i64 | 698i64 | 754i64 | 783i64 | 785i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2538i64); + } + self.parse_child(2536i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2538i64); + } + self.parse_child(698i64, &mut branch_matches, &mut has_children); + self.parse_child(682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2538i64); + } + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + self.parse_child(682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2538i64); + } + self.parse_child(754i64, &mut branch_matches, &mut has_children); + self.parse_child(682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2538i64); + } + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + self.parse_child(682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFrameExclusion + fn parse_rule_2539(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 680i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2539i64); + } + self.parse_child(680i64, &mut branch_matches, &mut has_children); + self.parse_child(2540i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f378 + fn parse_rule_2540(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 101i64 | 217i64 | 373i64 | 697i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(101i64, &mut branch_matches, &mut has_children); + self.parse_child(487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(217i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(690i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f379 + fn parse_rule_2541(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(665i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f380 + fn parse_rule_2542(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2545i64, &mut branch_matches, &mut has_children); + self.parse_child(2542i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2545i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // withClause + fn parse_rule_2543(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2543i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(2541i64, &mut branch_matches, &mut has_children); + self.parse_child(2545i64, &mut branch_matches, &mut has_children); + self.parse_child(2542i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f381 + fn parse_rule_2544(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2545i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // commonTableExpression + fn parse_rule_2545(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2545i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f382 + fn parse_rule_2546(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2548i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // groupByClause + fn parse_rule_2547(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 217i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2547i64); + } + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + self.parse_child(2546i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // olapOption + fn parse_rule_2548(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2548i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(481i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2548i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(99i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f383 + fn parse_rule_2549(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(99i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // orderClause + fn parse_rule_2550(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 393i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2550i64); + } + self.parse_child(393i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // direction + fn parse_rule_2551(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 18i64 | 134i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2551i64); + } + self.parse_child(18i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2551i64); + } + self.parse_child(134i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fromClause + fn parse_rule_2552(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2552i64); + } + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(2553i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f384 + fn parse_rule_2553(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 149i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | + 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 752i64 | 753i64 | 781i64 | 784i64 | + 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | + 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | + 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(149i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2555i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f385 + fn parse_rule_2554(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2587i64, &mut branch_matches, &mut has_children); + self.parse_child(2554i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2587i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableReferenceList + fn parse_rule_2555(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 752i64 | 753i64 | 781i64 | 784i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2555i64); + } + self.parse_child(2587i64, &mut branch_matches, &mut has_children); + self.parse_child(2554i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f386 + fn parse_rule_2556(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2587i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f387 + fn parse_rule_2557(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2561i64, &mut branch_matches, &mut has_children); + self.parse_child(2557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2561i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableValueConstructor + fn parse_rule_2558(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 626i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2558i64); + } + self.parse_child(626i64, &mut branch_matches, &mut has_children); + self.parse_child(2561i64, &mut branch_matches, &mut has_children); + self.parse_child(2557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f388 + fn parse_rule_2559(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2561i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // explicitTable + fn parse_rule_2560(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2560i64); + } + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // rowValueExplicit + fn parse_rule_2561(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 487i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2561i64); + } + self.parse_child(487i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2419i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // selectOption + fn parse_rule_2562(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 143i64 | 223i64 | 325i64 | 531i64 | 532i64 | 533i64 | 534i64 | 535i64 | 536i64 | 555i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2562i64); + } + self.parse_child(2497i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2562i64); + } + self.parse_child(535i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2562i64); + } + self.parse_child(533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2562i64); + } + self.parse_child(325i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f389 + fn parse_rule_2563(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 533i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f390 + fn parse_rule_2564(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 325i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(325i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f391 + fn parse_rule_2565(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64 | 287i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2569i64, &mut branch_matches, &mut has_children); + self.parse_child(2565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2569i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockingClauseList + fn parse_rule_2566(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64 | 287i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2566i64); + } + self.parse_child(2565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f392 + fn parse_rule_2567(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(668i64, &mut branch_matches, &mut has_children); + self.parse_child(3816i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f393 + fn parse_rule_2568(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2576i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockingClause + fn parse_rule_2569(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64 | 287i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2569i64); + } + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(2574i64, &mut branch_matches, &mut has_children); + self.parse_child(2567i64, &mut branch_matches, &mut has_children); + self.parse_child(2568i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2569i64); + } + self.parse_child(287i64, &mut branch_matches, &mut has_children); + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(508i64, &mut branch_matches, &mut has_children); + self.parse_child(346i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f394 + fn parse_rule_2570(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 668i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(668i64, &mut branch_matches, &mut has_children); + self.parse_child(3816i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f395 + fn parse_rule_2571(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 668i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(668i64, &mut branch_matches, &mut has_children); + self.parse_child(3816i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f396 + fn parse_rule_2572(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 669i64 | 671i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2576i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f397 + fn parse_rule_2573(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 669i64 | 671i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2576i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockStrengh + fn parse_rule_2574(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 508i64 | 614i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2574i64); + } + self.parse_child(614i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2574i64); + } + self.parse_child(508i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f398 + fn parse_rule_2575(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 508i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(508i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockedRowAction + fn parse_rule_2576(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 669i64 | 671i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2576i64); + } + self.parse_child(669i64, &mut branch_matches, &mut has_children); + self.parse_child(670i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2576i64); + } + self.parse_child(671i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f399 + fn parse_rule_2577(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2582i64, &mut branch_matches, &mut has_children); + self.parse_child(2577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // selectItemList + fn parse_rule_2578(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 775i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | + 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2578i64); + } + self.parse_child(2579i64, &mut branch_matches, &mut has_children); + self.parse_child(2577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f400 + fn parse_rule_2579(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 775i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | + 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f401 + fn parse_rule_2580(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f402 + fn parse_rule_2581(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // selectItem + fn parse_rule_2582(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2582i64); + } + self.parse_child(3778i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2582i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(2581i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // selectAlias + fn parse_rule_2583(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 17i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2583i64); + } + self.parse_child(2198i64, &mut branch_matches, &mut has_children); + self.parse_child(2584i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f403 + fn parse_rule_2584(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // whereClause + fn parse_rule_2585(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 643i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2585i64); + } + self.parse_child(643i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f404 + fn parse_rule_2586(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2593i64, &mut branch_matches, &mut has_children); + self.parse_child(2586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2593i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableReference + fn parse_rule_2587(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 752i64 | 753i64 | 781i64 | 784i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2587i64); + } + self.parse_child(2590i64, &mut branch_matches, &mut has_children); + self.parse_child(2586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f405 + fn parse_rule_2588(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f406 + fn parse_rule_2589(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(732i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f407 + fn parse_rule_2590(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 752i64 | 753i64 | 781i64 | 784i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2605i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(752i64, &mut branch_matches, &mut has_children); + self.parse_child(2589i64, &mut branch_matches, &mut has_children); + self.parse_child(2591i64, &mut branch_matches, &mut has_children); + self.parse_child(747i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // escapedTableReference + fn parse_rule_2591(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2591i64); + } + self.parse_child(2605i64, &mut branch_matches, &mut has_children); + self.parse_child(2586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f408 + fn parse_rule_2592(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2594i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // joinedTable + fn parse_rule_2593(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 98i64 | 239i64 | 261i64 | 272i64 | 359i64 | 478i64 | 555i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2593i64); + } + self.parse_child(2601i64, &mut branch_matches, &mut has_children); + self.parse_child(2587i64, &mut branch_matches, &mut has_children); + self.parse_child(2592i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2593i64); + } + self.parse_child(2603i64, &mut branch_matches, &mut has_children); + self.parse_child(2587i64, &mut branch_matches, &mut has_children); + self.parse_child(2595i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2593i64); + } + self.parse_child(2598i64, &mut branch_matches, &mut has_children); + self.parse_child(2605i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f409 + fn parse_rule_2594(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64 | 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(3834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f410 + fn parse_rule_2595(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64 | 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(3834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f411 + fn parse_rule_2596(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(239i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f412 + fn parse_rule_2597(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // naturalJoinType + fn parse_rule_2598(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 359i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2598i64); + } + self.parse_child(359i64, &mut branch_matches, &mut has_children); + self.parse_child(2596i64, &mut branch_matches, &mut has_children); + self.parse_child(261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2598i64); + } + self.parse_child(359i64, &mut branch_matches, &mut has_children); + self.parse_child(2599i64, &mut branch_matches, &mut has_children); + self.parse_child(2597i64, &mut branch_matches, &mut has_children); + self.parse_child(261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f413 + fn parse_rule_2599(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 272i64 | 478i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(272i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(478i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f414 + fn parse_rule_2600(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2602i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // innerJoinType + fn parse_rule_2601(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 98i64 | 239i64 | 261i64 | 555i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2601i64); + } + self.parse_child(2600i64, &mut branch_matches, &mut has_children); + self.parse_child(261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2601i64); + } + self.parse_child(555i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f415 + fn parse_rule_2602(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 98i64 | 239i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(239i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(98i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // outerJoinType + fn parse_rule_2603(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 272i64 | 478i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2603i64); + } + self.parse_child(2604i64, &mut branch_matches, &mut has_children); + self.parse_child(2597i64, &mut branch_matches, &mut has_children); + self.parse_child(261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f416 + fn parse_rule_2604(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 272i64 | 478i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(272i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(478i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableFactor + fn parse_rule_2605(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2605i64); + } + self.parse_child(2608i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2605i64); + } + self.parse_child(2609i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2605i64); + } + self.parse_child(2612i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2605i64); + } + self.parse_child(2616i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2605i64); + } + self.parse_child(2618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f417 + fn parse_rule_2606(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 701i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f418 + fn parse_rule_2607(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2640i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // singleTable + fn parse_rule_2608(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2608i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2398i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + self.parse_child(2607i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // singleTableParens + fn parse_rule_2609(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2609i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2610i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f419 + fn parse_rule_2610(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2608i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2609i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f420 + fn parse_rule_2611(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3771i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // derivedTable + fn parse_rule_2612(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 726i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2612i64); + } + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + self.parse_child(2611i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2612i64); + } + self.parse_child(726i64, &mut branch_matches, &mut has_children); + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f421 + fn parse_rule_2613(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3771i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f422 + fn parse_rule_2614(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3771i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f423 + fn parse_rule_2615(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 726i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(726i64, &mut branch_matches, &mut has_children); + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableReferenceListParens + fn parse_rule_2616(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2616i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2617i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f424 + fn parse_rule_2617(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 701i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 726i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 752i64 | 753i64 | 781i64 | 784i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2555i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2616i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableFunction + fn parse_rule_2618(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 701i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2618i64); + } + self.parse_child(701i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2620i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f425 + fn parse_rule_2619(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2625i64, &mut branch_matches, &mut has_children); + self.parse_child(2619i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2625i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnsClause + fn parse_rule_2620(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 71i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2620i64); + } + self.parse_child(71i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2625i64, &mut branch_matches, &mut has_children); + self.parse_child(2619i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f426 + fn parse_rule_2621(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2625i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f427 + fn parse_rule_2622(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f428 + fn parse_rule_2623(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(174i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f429 + fn parse_rule_2624(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2630i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // jtColumn + fn parse_rule_2625(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2625i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2625i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3592i64, &mut branch_matches, &mut has_children); + self.parse_child(2622i64, &mut branch_matches, &mut has_children); + self.parse_child(2623i64, &mut branch_matches, &mut has_children); + self.parse_child(704i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2624i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2625i64); + } + self.parse_child(702i64, &mut branch_matches, &mut has_children); + self.parse_child(704i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2620i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f430 + fn parse_rule_2626(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 69i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f431 + fn parse_rule_2627(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 69i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f432 + fn parse_rule_2628(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2632i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f433 + fn parse_rule_2629(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2631i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // onEmptyOrError + fn parse_rule_2630(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 165i64 | 376i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2630i64); + } + self.parse_child(2631i64, &mut branch_matches, &mut has_children); + self.parse_child(2628i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2630i64); + } + self.parse_child(2632i64, &mut branch_matches, &mut has_children); + self.parse_child(2629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // onEmpty + fn parse_rule_2631(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 165i64 | 376i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2631i64); + } + self.parse_child(2633i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(700i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // onError + fn parse_rule_2632(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 165i64 | 376i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2632i64); + } + self.parse_child(2633i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // jtOnResponse + fn parse_rule_2633(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 165i64 | 376i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2633i64); + } + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2633i64); + } + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2633i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setOperationOption + fn parse_rule_2634(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 143i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2634i64); + } + self.parse_child(143i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2634i64); + } + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f434 + fn parse_rule_2635(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2638i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableAlias + fn parse_rule_2636(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 17i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 763i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2636i64); + } + self.parse_child(2635i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f435 + fn parse_rule_2637(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 763i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f436 + fn parse_rule_2638(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64 | 763i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f437 + fn parse_rule_2639(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 198i64 | 232i64 | 620i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2643i64, &mut branch_matches, &mut has_children); + self.parse_child(2639i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2643i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexHintList + fn parse_rule_2640(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 198i64 | 232i64 | 620i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2640i64); + } + self.parse_child(2639i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f438 + fn parse_rule_2641(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2648i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f439 + fn parse_rule_2642(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2651i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexHint + fn parse_rule_2643(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 198i64 | 232i64 | 620i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2643i64); + } + self.parse_child(2644i64, &mut branch_matches, &mut has_children); + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + self.parse_child(2641i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2651i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2643i64); + } + self.parse_child(620i64, &mut branch_matches, &mut has_children); + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + self.parse_child(2641i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2642i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexHintType + fn parse_rule_2644(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 198i64 | 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2644i64); + } + self.parse_child(198i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2644i64); + } + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyOrIndex + fn parse_rule_2645(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 236i64 | 265i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2645i64); + } + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2645i64); + } + self.parse_child(236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f440 + fn parse_rule_2646(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // constraintKeyType + fn parse_rule_2647(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 420i64 | 609i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2647i64); + } + self.parse_child(420i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2647i64); + } + self.parse_child(609i64, &mut branch_matches, &mut has_children); + self.parse_child(2646i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexHintClause + fn parse_rule_2648(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2648i64); + } + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(2649i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f441 + fn parse_rule_2649(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 217i64 | 261i64 | 393i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(393i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f442 + fn parse_rule_2650(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2653i64, &mut branch_matches, &mut has_children); + self.parse_child(2650i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexList + fn parse_rule_2651(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2651i64); + } + self.parse_child(2653i64, &mut branch_matches, &mut has_children); + self.parse_child(2650i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f443 + fn parse_rule_2652(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexListElement + fn parse_rule_2653(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2653i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2653i64); + } + self.parse_child(420i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f444 + fn parse_rule_2654(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f445 + fn parse_rule_2655(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(295i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // updateStatement + fn parse_rule_2656(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 614i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2656i64); + } + self.parse_child(2654i64, &mut branch_matches, &mut has_children); + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(2655i64, &mut branch_matches, &mut has_children); + self.parse_child(2396i64, &mut branch_matches, &mut has_children); + self.parse_child(2555i64, &mut branch_matches, &mut has_children); + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3704i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(2375i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f446 + fn parse_rule_2657(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f447 + fn parse_rule_2658(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // transactionOrLockingStatement + fn parse_rule_2659(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 77i64 | 287i64 | 450i64 | 480i64 | 489i64 | 543i64 | 611i64 | 651i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2659i64); + } + self.parse_child(2664i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2659i64); + } + self.parse_child(2675i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2659i64); + } + self.parse_child(2683i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2659i64); + } + self.parse_child(2691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f448 + fn parse_rule_2660(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2670i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f449 + fn parse_rule_2661(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(647i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f450 + fn parse_rule_2662(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(15i64, &mut branch_matches, &mut has_children); + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(54i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f451 + fn parse_rule_2663(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(450i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // transactionStatement + fn parse_rule_2664(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 77i64 | 543i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2664i64); + } + self.parse_child(543i64, &mut branch_matches, &mut has_children); + self.parse_child(592i64, &mut branch_matches, &mut has_children); + self.parse_child(2660i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2664i64); + } + self.parse_child(77i64, &mut branch_matches, &mut has_children); + self.parse_child(2661i64, &mut branch_matches, &mut has_children); + self.parse_child(2662i64, &mut branch_matches, &mut has_children); + self.parse_child(2663i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f452 + fn parse_rule_2665(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f453 + fn parse_rule_2666(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 15i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(15i64, &mut branch_matches, &mut has_children); + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(54i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f454 + fn parse_rule_2667(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 373i64 | 450i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(450i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // beginWork + fn parse_rule_2668(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 29i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2668i64); + } + self.parse_child(29i64, &mut branch_matches, &mut has_children); + self.parse_child(2661i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f455 + fn parse_rule_2669(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2672i64, &mut branch_matches, &mut has_children); + self.parse_child(2669i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2672i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // transactionCharacteristicList + fn parse_rule_2670(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 435i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2670i64); + } + self.parse_child(2672i64, &mut branch_matches, &mut has_children); + self.parse_child(2669i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f456 + fn parse_rule_2671(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2672i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // transactionCharacteristic + fn parse_rule_2672(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 435i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2672i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(85i64, &mut branch_matches, &mut has_children); + self.parse_child(517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2672i64); + } + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(2673i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f457 + fn parse_rule_2673(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 386i64 | 649i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(649i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f458 + fn parse_rule_2674(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 435i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(2673i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // savepointStatement + fn parse_rule_2675(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 450i64 | 480i64 | 489i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2675i64); + } + self.parse_child(489i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2675i64); + } + self.parse_child(480i64, &mut branch_matches, &mut has_children); + self.parse_child(2661i64, &mut branch_matches, &mut has_children); + self.parse_child(2681i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2675i64); + } + self.parse_child(450i64, &mut branch_matches, &mut has_children); + self.parse_child(489i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f459 + fn parse_rule_2676(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(15i64, &mut branch_matches, &mut has_children); + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(54i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f460 + fn parse_rule_2677(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 15i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(15i64, &mut branch_matches, &mut has_children); + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(54i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f461 + fn parse_rule_2678(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(450i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f462 + fn parse_rule_2679(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 373i64 | 450i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(450i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f463 + fn parse_rule_2680(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(489i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f464 + fn parse_rule_2681(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2680i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2676i64, &mut branch_matches, &mut has_children); + self.parse_child(2678i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f465 + fn parse_rule_2682(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2689i64, &mut branch_matches, &mut has_children); + self.parse_child(2682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockStatement + fn parse_rule_2683(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 287i64 | 611i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2683i64); + } + self.parse_child(287i64, &mut branch_matches, &mut has_children); + self.parse_child(2684i64, &mut branch_matches, &mut has_children); + self.parse_child(2689i64, &mut branch_matches, &mut has_children); + self.parse_child(2682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2683i64); + } + self.parse_child(287i64, &mut branch_matches, &mut has_children); + self.parse_child(244i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(27i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2683i64); + } + self.parse_child(611i64, &mut branch_matches, &mut has_children); + self.parse_child(2688i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f466 + fn parse_rule_2684(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f467 + fn parse_rule_2685(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f468 + fn parse_rule_2686(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 287i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(287i64, &mut branch_matches, &mut has_children); + self.parse_child(244i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(27i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f469 + fn parse_rule_2687(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 244i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f470 + fn parse_rule_2688(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 244i64 | 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockItem + fn parse_rule_2689(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2689i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(2388i64, &mut branch_matches, &mut has_children); + self.parse_child(2690i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lockOption + fn parse_rule_2690(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 295i64 | 435i64 | 649i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2690i64); + } + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(2431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2690i64); + } + self.parse_child(2655i64, &mut branch_matches, &mut has_children); + self.parse_child(649i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // xaStatement + fn parse_rule_2691(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 651i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2691i64); + } + self.parse_child(651i64, &mut branch_matches, &mut has_children); + self.parse_child(2701i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f471 + fn parse_rule_2692(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 29i64 | 543i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(29i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f472 + fn parse_rule_2693(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2694i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f473 + fn parse_rule_2694(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 261i64 | 472i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(472i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f474 + fn parse_rule_2695(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(340i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f475 + fn parse_rule_2696(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(340i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f476 + fn parse_rule_2697(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(566i64, &mut branch_matches, &mut has_children); + self.parse_child(2695i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f477 + fn parse_rule_2698(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 566i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(566i64, &mut branch_matches, &mut has_children); + self.parse_child(2695i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f478 + fn parse_rule_2699(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(384i64, &mut branch_matches, &mut has_children); + self.parse_child(407i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f479 + fn parse_rule_2700(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 384i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(384i64, &mut branch_matches, &mut has_children); + self.parse_child(407i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f480 + fn parse_rule_2701(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 29i64 | 77i64 | 159i64 | 417i64 | 439i64 | 480i64 | 543i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2692i64, &mut branch_matches, &mut has_children); + self.parse_child(2707i64, &mut branch_matches, &mut has_children); + self.parse_child(2693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(159i64, &mut branch_matches, &mut has_children); + self.parse_child(2707i64, &mut branch_matches, &mut has_children); + self.parse_child(2697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(417i64, &mut branch_matches, &mut has_children); + self.parse_child(2707i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(77i64, &mut branch_matches, &mut has_children); + self.parse_child(2707i64, &mut branch_matches, &mut has_children); + self.parse_child(2699i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(480i64, &mut branch_matches, &mut has_children); + self.parse_child(2707i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(439i64, &mut branch_matches, &mut has_children); + self.parse_child(2702i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // xaConvert + fn parse_rule_2702(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2702i64); + } + self.parse_child(2703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2702i64); + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f481 + fn parse_rule_2703(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(94i64, &mut branch_matches, &mut has_children); + self.parse_child(652i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f482 + fn parse_rule_2704(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 94i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(94i64, &mut branch_matches, &mut has_children); + self.parse_child(652i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f483 + fn parse_rule_2705(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f484 + fn parse_rule_2706(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(2708i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // xid + fn parse_rule_2707(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 782i64 | 784i64 | 786i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2707i64); + } + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(2706i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f485 + fn parse_rule_2708(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f486 + fn parse_rule_2709(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f487 + fn parse_rule_2710(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(2708i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f488 + fn parse_rule_2711(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2724i64, &mut branch_matches, &mut has_children); + self.parse_child(2711i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // replicationStatement + fn parse_rule_2712(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 55i64 | 281i64 | 428i64 | 468i64 | 543i64 | 552i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(428i64, &mut branch_matches, &mut has_children); + self.parse_child(2713i64, &mut branch_matches, &mut has_children); + self.parse_child(289i64, &mut branch_matches, &mut has_children); + self.parse_child(2714i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(2733i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(468i64, &mut branch_matches, &mut has_children); + self.parse_child(2724i64, &mut branch_matches, &mut has_children); + self.parse_child(2711i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(468i64, &mut branch_matches, &mut has_children); + self.parse_child(658i64, &mut branch_matches, &mut has_children); + self.parse_child(2716i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(2804i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(2749i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(2731i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2712i64); + } + self.parse_child(2827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f489 + fn parse_rule_2713(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 316i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f490 + fn parse_rule_2714(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 28i64 | 590i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(28i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f491 + fn parse_rule_2715(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f492 + fn parse_rule_2716(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f493 + fn parse_rule_2717(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2323i64, &mut branch_matches, &mut has_children); + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f494 + fn parse_rule_2718(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 468i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(468i64, &mut branch_matches, &mut has_children); + self.parse_child(658i64, &mut branch_matches, &mut has_children); + self.parse_child(2716i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f495 + fn parse_rule_2719(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 55i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2749i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f496 + fn parse_rule_2720(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 543i64 | 552i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f497 + fn parse_rule_2721(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2726i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f498 + fn parse_rule_2722(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f499 + fn parse_rule_2723(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resetOption + fn parse_rule_2724(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 316i64 | 430i64 | 514i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2724i64); + } + self.parse_child(316i64, &mut branch_matches, &mut has_children); + self.parse_child(2721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2724i64); + } + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(47i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2724i64); + } + self.parse_child(514i64, &mut branch_matches, &mut has_children); + self.parse_child(2722i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f500 + fn parse_rule_2725(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 430i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(47i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // masterResetOptions + fn parse_rule_2726(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 590i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2726i64); + } + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2729i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f501 + fn parse_rule_2727(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f502 + fn parse_rule_2728(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f503 + fn parse_rule_2729(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f504 + fn parse_rule_2730(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 590i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2729i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // replicationLoad + fn parse_rule_2731(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 281i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2731i64); + } + self.parse_child(281i64, &mut branch_matches, &mut has_children); + self.parse_child(2732i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f505 + fn parse_rule_2732(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 112i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // changeMaster + fn parse_rule_2733(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 55i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2733i64); + } + self.parse_child(55i64, &mut branch_matches, &mut has_children); + self.parse_child(316i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2735i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f506 + fn parse_rule_2734(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2737i64, &mut branch_matches, &mut has_children); + self.parse_child(2734i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2737i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // changeMasterOptions + fn parse_rule_2735(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 233i64 | 296i64 | 297i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 315i64 | 317i64 | 318i64 | 319i64 | 447i64 | 448i64 | 712i64 | 713i64 | 729i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 742i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2735i64); + } + self.parse_child(2737i64, &mut branch_matches, &mut has_children); + self.parse_child(2734i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f507 + fn parse_rule_2736(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2737i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // masterOption + fn parse_rule_2737(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 233i64 | 296i64 | 297i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 315i64 | 317i64 | 318i64 | 319i64 | 447i64 | 448i64 | 712i64 | 713i64 | 729i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 742i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(300i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(729i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(297i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(318i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(303i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(304i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(298i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(305i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(299i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(314i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(308i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(307i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(317i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(309i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(738i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2740i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(310i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(313i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(315i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(311i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(312i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(712i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(713i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(319i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(233i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2743i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(735i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(736i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(296i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(737i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2738i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(739i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(742i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2739i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2737i64); + } + self.parse_child(2741i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // privilegeCheckDef + fn parse_rule_2738(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2738i64); + } + self.parse_child(3755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2738i64); + } + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tablePrimaryKeyCheckDef + fn parse_rule_2739(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64 | 743i64 | 744i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2739i64); + } + self.parse_child(743i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2739i64); + } + self.parse_child(383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2739i64); + } + self.parse_child(744i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // masterTlsCiphersuitesDef + fn parse_rule_2740(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 376i64 | 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2740i64); + } + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2740i64); + } + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // masterFileDef + fn parse_rule_2741(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 301i64 | 302i64 | 447i64 | 448i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2741i64); + } + self.parse_child(301i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2741i64); + } + self.parse_child(302i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2741i64); + } + self.parse_child(447i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2741i64); + } + self.parse_child(448i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f508 + fn parse_rule_2742(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(2744i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // serverIdList + fn parse_rule_2743(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2743i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2742i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f509 + fn parse_rule_2744(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(2744i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f510 + fn parse_rule_2745(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f511 + fn parse_rule_2746(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 783i64 | 785i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(2744i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f512 + fn parse_rule_2747(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2788i64, &mut branch_matches, &mut has_children); + self.parse_child(2747i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f513 + fn parse_rule_2748(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // changeReplication + fn parse_rule_2749(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 55i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2749i64); + } + self.parse_child(55i64, &mut branch_matches, &mut has_children); + self.parse_child(459i64, &mut branch_matches, &mut has_children); + self.parse_child(522i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2754i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2749i64); + } + self.parse_child(55i64, &mut branch_matches, &mut has_children); + self.parse_child(459i64, &mut branch_matches, &mut has_children); + self.parse_child(190i64, &mut branch_matches, &mut has_children); + self.parse_child(2788i64, &mut branch_matches, &mut has_children); + self.parse_child(2747i64, &mut branch_matches, &mut has_children); + self.parse_child(2748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f514 + fn parse_rule_2750(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f515 + fn parse_rule_2751(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f516 + fn parse_rule_2752(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f517 + fn parse_rule_2753(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2756i64, &mut branch_matches, &mut has_children); + self.parse_child(2753i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2756i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // changeReplicationSourceOptions + fn parse_rule_2754(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 233i64 | 296i64 | 297i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 315i64 | 317i64 | 318i64 | 319i64 | 447i64 | 448i64 | 712i64 | 713i64 | 729i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 742i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2754i64); + } + self.parse_child(2756i64, &mut branch_matches, &mut has_children); + self.parse_child(2753i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f518 + fn parse_rule_2755(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2756i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // replicationSourceOption + fn parse_rule_2756(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 233i64 | 296i64 | 297i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 315i64 | 317i64 | 318i64 | 319i64 | 447i64 | 448i64 | 712i64 | 713i64 | 729i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 742i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2757i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2758i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2759i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2760i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2761i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2762i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2763i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2764i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2765i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2766i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2767i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(817i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2768i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2769i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2770i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2771i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2772i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2773i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2774i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2775i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2776i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2777i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2778i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2779i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2780i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2781i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2740i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2782i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(2783i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(729i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(233i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2743i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(841i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(737i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2738i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(739i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(742i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(2739i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 34 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(842i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 35 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(447i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 36 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2756i64); + } + self.parse_child(448i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f519 + fn parse_rule_2757(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 297i64 | 814i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(814i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(297i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f520 + fn parse_rule_2758(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 300i64 | 820i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(300i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f521 + fn parse_rule_2759(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 318i64 | 838i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(838i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(318i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f522 + fn parse_rule_2760(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 303i64 | 823i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(823i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(303i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f523 + fn parse_rule_2761(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 304i64 | 824i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(824i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f524 + fn parse_rule_2762(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 301i64 | 821i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(821i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(301i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f525 + fn parse_rule_2763(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 302i64 | 822i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(822i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(302i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f526 + fn parse_rule_2764(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 296i64 | 813i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(813i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(296i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f527 + fn parse_rule_2765(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 319i64 | 819i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(819i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(319i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f528 + fn parse_rule_2766(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 298i64 | 816i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(816i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(298i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f529 + fn parse_rule_2767(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 305i64 | 826i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(826i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(305i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f530 + fn parse_rule_2768(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 299i64 | 818i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(818i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(299i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f531 + fn parse_rule_2769(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 735i64 | 815i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(815i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(735i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f532 + fn parse_rule_2770(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 736i64 | 839i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(839i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(736i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f533 + fn parse_rule_2771(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 314i64 | 827i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(314i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f534 + fn parse_rule_2772(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 308i64 | 828i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(828i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(308i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f535 + fn parse_rule_2773(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 307i64 | 829i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(829i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(307i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f536 + fn parse_rule_2774(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 309i64 | 830i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(309i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f537 + fn parse_rule_2775(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 311i64 | 832i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(311i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f538 + fn parse_rule_2776(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 312i64 | 833i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(833i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(312i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f539 + fn parse_rule_2777(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 313i64 | 834i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(313i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f540 + fn parse_rule_2778(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 310i64 | 831i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(831i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(310i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f541 + fn parse_rule_2779(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 315i64 | 835i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(315i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f542 + fn parse_rule_2780(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 317i64 | 837i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(837i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(317i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f543 + fn parse_rule_2781(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 738i64 | 836i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(836i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(738i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f544 + fn parse_rule_2782(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 712i64 | 825i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(825i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(712i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f545 + fn parse_rule_2783(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 713i64 | 840i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(713i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f546 + fn parse_rule_2784(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2790i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f547 + fn parse_rule_2785(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2793i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f548 + fn parse_rule_2786(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2796i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f549 + fn parse_rule_2787(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2800i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterDefinition + fn parse_rule_2788(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(460i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2784i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(461i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2784i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(462i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2785i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(463i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2785i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(464i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2786i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(465i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2786i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2788i64); + } + self.parse_child(466i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2787i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f550 + fn parse_rule_2789(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + self.parse_child(2789i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterDbList + fn parse_rule_2790(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2790i64); + } + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + self.parse_child(2789i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f551 + fn parse_rule_2791(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f552 + fn parse_rule_2792(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3804i64, &mut branch_matches, &mut has_children); + self.parse_child(2792i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3804i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterTableList + fn parse_rule_2793(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2793i64); + } + self.parse_child(3804i64, &mut branch_matches, &mut has_children); + self.parse_child(2792i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f553 + fn parse_rule_2794(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3804i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f554 + fn parse_rule_2795(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2798i64, &mut branch_matches, &mut has_children); + self.parse_child(2795i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2798i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterStringList + fn parse_rule_2796(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2796i64); + } + self.parse_child(2798i64, &mut branch_matches, &mut has_children); + self.parse_child(2795i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f555 + fn parse_rule_2797(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2798i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterWildDbTableString + fn parse_rule_2798(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2798i64); + } + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f556 + fn parse_rule_2799(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3699i64, &mut branch_matches, &mut has_children); + self.parse_child(2799i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3699i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterDbPairList + fn parse_rule_2800(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2800i64); + } + self.parse_child(3699i64, &mut branch_matches, &mut has_children); + self.parse_child(2799i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f557 + fn parse_rule_2801(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3699i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f558 + fn parse_rule_2802(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2824i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f559 + fn parse_rule_2803(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(613i64, &mut branch_matches, &mut has_children); + self.parse_child(2807i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // slave + fn parse_rule_2804(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 543i64 | 552i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2804i64); + } + self.parse_child(543i64, &mut branch_matches, &mut has_children); + self.parse_child(514i64, &mut branch_matches, &mut has_children); + self.parse_child(2802i64, &mut branch_matches, &mut has_children); + self.parse_child(2803i64, &mut branch_matches, &mut has_children); + self.parse_child(2813i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2804i64); + } + self.parse_child(552i64, &mut branch_matches, &mut has_children); + self.parse_child(514i64, &mut branch_matches, &mut has_children); + self.parse_child(2802i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f560 + fn parse_rule_2805(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 613i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(613i64, &mut branch_matches, &mut has_children); + self.parse_child(2807i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f561 + fn parse_rule_2806(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2741i64, &mut branch_matches, &mut has_children); + self.parse_child(2806i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2741i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // slaveUntilOptions + fn parse_rule_2807(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 301i64 | 302i64 | 447i64 | 448i64 | 528i64 | 529i64 | 530i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2807i64); + } + self.parse_child(2811i64, &mut branch_matches, &mut has_children); + self.parse_child(2806i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f562 + fn parse_rule_2808(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 528i64 | 530i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(530i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(528i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f563 + fn parse_rule_2809(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 528i64 | 530i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2808i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f564 + fn parse_rule_2810(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 529i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(529i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f565 + fn parse_rule_2811(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 301i64 | 302i64 | 447i64 | 448i64 | 528i64 | 529i64 | 530i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2741i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2808i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(529i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f566 + fn parse_rule_2812(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2741i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // slaveConnectionOptions + fn parse_rule_2813(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2813i64); + } + self.parse_child(2814i64, &mut branch_matches, &mut has_children); + self.parse_child(2816i64, &mut branch_matches, &mut has_children); + self.parse_child(2818i64, &mut branch_matches, &mut has_children); + self.parse_child(2820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2813i64); + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f567 + fn parse_rule_2814(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f568 + fn parse_rule_2815(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 618i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f569 + fn parse_rule_2816(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f570 + fn parse_rule_2817(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 406i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f571 + fn parse_rule_2818(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(129i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f572 + fn parse_rule_2819(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 129i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(129i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f573 + fn parse_rule_2820(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(409i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f574 + fn parse_rule_2821(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 409i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(409i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f575 + fn parse_rule_2822(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2814i64, &mut branch_matches, &mut has_children); + self.parse_child(2816i64, &mut branch_matches, &mut has_children); + self.parse_child(2818i64, &mut branch_matches, &mut has_children); + self.parse_child(2820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f576 + fn parse_rule_2823(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2826i64, &mut branch_matches, &mut has_children); + self.parse_child(2823i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2826i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // slaveThreadOptions + fn parse_rule_2824(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 449i64 | 538i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2824i64); + } + self.parse_child(2826i64, &mut branch_matches, &mut has_children); + self.parse_child(2823i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f577 + fn parse_rule_2825(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2826i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // slaveThreadOption + fn parse_rule_2826(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 449i64 | 538i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2826i64); + } + self.parse_child(449i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2826i64); + } + self.parse_child(538i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // groupReplication + fn parse_rule_2827(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 543i64 | 552i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2827i64); + } + self.parse_child(2828i64, &mut branch_matches, &mut has_children); + self.parse_child(210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f578 + fn parse_rule_2828(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 543i64 | 552i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(552i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // preparedStatement + fn parse_rule_2829(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 123i64 | 148i64 | 173i64 | 417i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2829i64); + } + self.parse_child(417i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(2830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2829i64); + } + self.parse_child(2833i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2829i64); + } + self.parse_child(2831i64, &mut branch_matches, &mut has_children); + self.parse_child(417i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f579 + fn parse_rule_2830(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 746i64 | 784i64 | 789i64 | 790i64 | 792i64 | 794i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f580 + fn parse_rule_2831(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 123i64 | 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(148i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f581 + fn parse_rule_2832(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(2836i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // executeStatement + fn parse_rule_2833(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 173i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2833i64); + } + self.parse_child(173i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(2832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f582 + fn parse_rule_2834(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(2836i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f583 + fn parse_rule_2835(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + self.parse_child(2835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // executeVarList + fn parse_rule_2836(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 746i64 | 792i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2836i64); + } + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + self.parse_child(2835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f584 + fn parse_rule_2837(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // cloneStatement + fn parse_rule_2838(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 677i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2838i64); + } + self.parse_child(677i64, &mut branch_matches, &mut has_children); + self.parse_child(2844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f585 + fn parse_rule_2839(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(459i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f586 + fn parse_rule_2840(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(459i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f587 + fn parse_rule_2841(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2846i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f588 + fn parse_rule_2842(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 244i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(749i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f589 + fn parse_rule_2843(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f590 + fn parse_rule_2844(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 244i64 | 284i64 | 676i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(284i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(676i64, &mut branch_matches, &mut has_children); + self.parse_child(2839i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(749i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f591 + fn parse_rule_2845(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dataDirSSL + fn parse_rule_2846(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 112i64 | 467i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2846i64); + } + self.parse_child(2847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2846i64); + } + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(2845i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ssl + fn parse_rule_2847(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 467i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2847i64); + } + self.parse_child(467i64, &mut branch_matches, &mut has_children); + self.parse_child(2665i64, &mut branch_matches, &mut has_children); + self.parse_child(539i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // accountManagementStatement + fn parse_rule_2848(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64 | 97i64 | 148i64 | 215i64 | 453i64 | 477i64 | 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2852i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2863i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2897i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2900i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2929i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2933i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2848i64); + } + self.parse_child(2979i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f592 + fn parse_rule_2849(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2852i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f593 + fn parse_rule_2850(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2979i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f594 + fn parse_rule_2851(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterUser + fn parse_rule_2852(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2852i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(2851i64, &mut branch_matches, &mut has_children); + self.parse_child(2855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f595 + fn parse_rule_2853(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f596 + fn parse_rule_2854(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterUserTail + fn parse_rule_2855(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2855i64); + } + self.parse_child(2856i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2857i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2855i64); + } + self.parse_child(2861i64, &mut branch_matches, &mut has_children); + self.parse_child(2866i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f597 + fn parse_rule_2856(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2862i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f598 + fn parse_rule_2857(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | + 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | + 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | + 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | + 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | + 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | + 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | + 417i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | + 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | + 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | + 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | + 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | + 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | + 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | + 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | + 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f599 + fn parse_rule_2858(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2856i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2857i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f600 + fn parse_rule_2859(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f601 + fn parse_rule_2860(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f602 + fn parse_rule_2861(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // userFunction + fn parse_rule_2862(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 618i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2862i64); + } + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(3876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createUser + fn parse_rule_2863(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 97i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2863i64); + } + self.parse_child(97i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(2865i64, &mut branch_matches, &mut has_children); + self.parse_child(3721i64, &mut branch_matches, &mut has_children); + self.parse_child(2875i64, &mut branch_matches, &mut has_children); + self.parse_child(2866i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f603 + fn parse_rule_2864(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3692i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f604 + fn parse_rule_2865(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3692i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createUserTail + fn parse_rule_2866(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2866i64); + } + self.parse_child(2871i64, &mut branch_matches, &mut has_children); + self.parse_child(2872i64, &mut branch_matches, &mut has_children); + self.parse_child(2873i64, &mut branch_matches, &mut has_children); + self.parse_child(2869i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2866i64); + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f605 + fn parse_rule_2867(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 812i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(75i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(812i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f606 + fn parse_rule_2868(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 812i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2867i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f607 + fn parse_rule_2869(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2867i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f608 + fn parse_rule_2870(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 812i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2867i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f609 + fn parse_rule_2871(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2879i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f610 + fn parse_rule_2872(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2883i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f611 + fn parse_rule_2873(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2885i64, &mut branch_matches, &mut has_children); + self.parse_child(2873i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2885i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f612 + fn parse_rule_2874(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2871i64, &mut branch_matches, &mut has_children); + self.parse_child(2872i64, &mut branch_matches, &mut has_children); + self.parse_child(2873i64, &mut branch_matches, &mut has_children); + self.parse_child(2869i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // defaultRoleClause + fn parse_rule_2875(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2875i64); + } + self.parse_child(2876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2875i64); + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f613 + fn parse_rule_2876(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f614 + fn parse_rule_2877(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f615 + fn parse_rule_2878(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // requireClause + fn parse_rule_2879(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 467i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2879i64); + } + self.parse_child(467i64, &mut branch_matches, &mut has_children); + self.parse_child(2881i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f616 + fn parse_rule_2880(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 369i64 | 539i64 | 650i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(539i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(650i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f617 + fn parse_rule_2881(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 63i64 | 259i64 | 369i64 | 539i64 | 559i64 | 650i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2973i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2880i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f618 + fn parse_rule_2882(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 321i64 | 322i64 | 327i64 | 328i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2884i64, &mut branch_matches, &mut has_children); + self.parse_child(2882i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2884i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // connectOptions + fn parse_rule_2883(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2883i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(2882i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f619 + fn parse_rule_2884(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 321i64 | 322i64 | 327i64 | 328i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(322i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(327i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(321i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(328i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // accountLockPasswordExpireOptions + fn parse_rule_2885(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 2i64 | 406i64 | 740i64 | 741i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2885i64); + } + self.parse_child(2i64, &mut branch_matches, &mut has_children); + self.parse_child(2886i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2885i64); + } + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(2894i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2885i64); + } + self.parse_child(740i64, &mut branch_matches, &mut has_children); + self.parse_child(2895i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2885i64); + } + self.parse_child(741i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f620 + fn parse_rule_2886(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 287i64 | 611i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(287i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(611i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f621 + fn parse_rule_2887(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2888i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f622 + fn parse_rule_2888(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 247i64 | 365i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(122i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(365i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f623 + fn parse_rule_2889(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f624 + fn parse_rule_2890(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(122i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f625 + fn parse_rule_2891(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2892i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f626 + fn parse_rule_2892(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 719i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(719i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f627 + fn parse_rule_2893(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 467i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(467i64, &mut branch_matches, &mut has_children); + self.parse_child(101i64, &mut branch_matches, &mut has_children); + self.parse_child(2891i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f628 + fn parse_rule_2894(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 177i64 | 467i64 | 705i64 | 706i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(177i64, &mut branch_matches, &mut has_children); + self.parse_child(2887i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(705i64, &mut branch_matches, &mut has_children); + self.parse_child(2889i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(706i64, &mut branch_matches, &mut has_children); + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(2890i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(467i64, &mut branch_matches, &mut has_children); + self.parse_child(101i64, &mut branch_matches, &mut has_children); + self.parse_child(2891i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f629 + fn parse_rule_2895(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 698i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(698i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f630 + fn parse_rule_2896(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropUser + fn parse_rule_2897(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2897i64); + } + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(2896i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f631 + fn parse_rule_2898(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f632 + fn parse_rule_2899(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // grant + fn parse_rule_2900(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 215i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2900i64); + } + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(2912i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f633 + fn parse_rule_2901(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(660i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f634 + fn parse_rule_2902(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(660i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f635 + fn parse_rule_2903(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | + 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | + 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | + 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | + 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | + 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | + 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | + 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | + 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | 598i64 | + 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | + 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2952i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + self.parse_child(2901i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f636 + fn parse_rule_2904(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(421i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f637 + fn parse_rule_2905(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | + 26i64 | 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | + 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | + 123i64 | 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | + 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | + 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | + 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | + 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | + 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | + 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | + 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | + 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | + 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | + 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | + 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | + 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | + 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | + 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | + 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2952i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + self.parse_child(2904i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f638 + fn parse_rule_2906(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f639 + fn parse_rule_2907(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f640 + fn parse_rule_2908(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2950i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f641 + fn parse_rule_2909(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2926i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f642 + fn parse_rule_2910(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2916i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f643 + fn parse_rule_2911(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2925i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f644 + fn parse_rule_2912(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | + 26i64 | 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | + 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | + 123i64 | 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | + 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | + 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | + 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | + 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | + 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | + 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | + 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | + 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | + 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | + 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | + 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | + 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | + 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | + 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | + 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2952i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + self.parse_child(2901i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2905i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2913i64, &mut branch_matches, &mut has_children); + self.parse_child(2909i64, &mut branch_matches, &mut has_children); + self.parse_child(2910i64, &mut branch_matches, &mut has_children); + self.parse_child(2911i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(427i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2913i64, &mut branch_matches, &mut has_children); + self.parse_child(2906i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // grantTargetList + fn parse_rule_2913(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2913i64); + } + self.parse_child(3721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2913i64); + } + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f645 + fn parse_rule_2914(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f646 + fn parse_rule_2915(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // grantOptions + fn parse_rule_2916(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2916i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(2917i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2916i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f647 + fn parse_rule_2917(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 215i64 | 321i64 | 322i64 | 327i64 | 328i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2977i64, &mut branch_matches, &mut has_children); + self.parse_child(2917i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2977i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f648 + fn parse_rule_2918(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(2917i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f649 + fn parse_rule_2919(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // exceptRoleList + fn parse_rule_2920(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 663i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2920i64); + } + self.parse_child(663i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // withRoles + fn parse_rule_2921(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2921i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2923i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f650 + fn parse_rule_2922(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2920i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f651 + fn parse_rule_2923(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | + 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | + 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | + 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | + 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | + 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | + 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | + 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | + 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | + 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | + 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + self.parse_child(2922i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f652 + fn parse_rule_2924(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2921i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // grantAs + fn parse_rule_2925(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2925i64); + } + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(2924i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // versionedRequireClause + fn parse_rule_2926(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 467i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2926i64); + } + self.parse_child(2879i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f653 + fn parse_rule_2927(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 467i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2879i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f654 + fn parse_rule_2928(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(2928i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // renameUser + fn parse_rule_2929(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 453i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2929i64); + } + self.parse_child(453i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(2928i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f655 + fn parse_rule_2930(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f656 + fn parse_rule_2931(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f657 + fn parse_rule_2932(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(610i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // revoke + fn parse_rule_2933(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 477i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2933i64); + } + self.parse_child(477i64, &mut branch_matches, &mut has_children); + self.parse_child(2931i64, &mut branch_matches, &mut has_children); + self.parse_child(2942i64, &mut branch_matches, &mut has_children); + self.parse_child(2932i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f658 + fn parse_rule_2934(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f659 + fn parse_rule_2935(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3691i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f660 + fn parse_rule_2936(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | + 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | + 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | + 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | + 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | + 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | + 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | + 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | + 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | 598i64 | + 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | + 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2952i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f661 + fn parse_rule_2937(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2945i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f662 + fn parse_rule_2938(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2937i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f663 + fn parse_rule_2939(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64 | 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2937i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f664 + fn parse_rule_2940(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + self.parse_child(2938i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f665 + fn parse_rule_2941(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + self.parse_child(2938i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f666 + fn parse_rule_2942(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | + 26i64 | 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | + 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | + 123i64 | 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | + 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | + 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | + 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | + 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | + 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | + 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | + 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | + 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | + 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | + 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | + 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | + 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | + 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | + 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | + 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2952i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2952i64, &mut branch_matches, &mut has_children); + self.parse_child(2945i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + self.parse_child(2904i64, &mut branch_matches, &mut has_children); + self.parse_child(2941i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(427i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f667 + fn parse_rule_2943(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(610i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f668 + fn parse_rule_2944(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(610i64, &mut branch_matches, &mut has_children); + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // onTypeTo + fn parse_rule_2945(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2945i64); + } + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2945i64); + } + self.parse_child(2947i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f669 + fn parse_rule_2946(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f670 + fn parse_rule_2947(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f671 + fn parse_rule_2948(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(2908i64, &mut branch_matches, &mut has_children); + self.parse_child(2968i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f672 + fn parse_rule_2949(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2947i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // aclType + fn parse_rule_2950(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 206i64 | 422i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2950i64); + } + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2950i64); + } + self.parse_child(206i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2950i64); + } + self.parse_child(422i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f673 + fn parse_rule_2951(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2956i64, &mut branch_matches, &mut has_children); + self.parse_child(2951i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2956i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleOrPrivilegesList + fn parse_rule_2952(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | + 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | + 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | + 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | + 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | + 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | + 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | + 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | + 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | 598i64 | + 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | + 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2952i64); + } + self.parse_child(2956i64, &mut branch_matches, &mut has_children); + self.parse_child(2951i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f674 + fn parse_rule_2953(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2956i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f675 + fn parse_rule_2954(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2965i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f676 + fn parse_rule_2955(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleOrPrivilege + fn parse_rule_2956(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | + 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | + 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | + 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 236i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | + 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 287i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | + 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | + 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | + 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 443i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | + 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | + 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | + 509i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 594i64 | 597i64 | 598i64 | + 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 614i64 | 615i64 | 616i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | + 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(2958i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(2960i64, &mut branch_matches, &mut has_children); + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(2961i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(2963i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(509i64, &mut branch_matches, &mut has_children); + self.parse_child(110i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(97i64, &mut branch_matches, &mut has_children); + self.parse_child(2954i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(287i64, &mut branch_matches, &mut has_children); + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(459i64, &mut branch_matches, &mut has_children); + self.parse_child(2966i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(509i64, &mut branch_matches, &mut has_children); + self.parse_child(636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2956i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(2955i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f677 + fn parse_rule_2957(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 746i64 | 792i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(792i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(746i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f678 + fn parse_rule_2958(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | + 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | + 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3874i64, &mut branch_matches, &mut has_children); + self.parse_child(2957i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3874i64, &mut branch_matches, &mut has_children); + self.parse_child(2168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f679 + fn parse_rule_2959(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | + 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | + 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2958i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f680 + fn parse_rule_2960(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 242i64 | 443i64 | 497i64 | 614i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(497i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(614i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(443i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f681 + fn parse_rule_2961(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 97i64 | 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(97i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(148i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f682 + fn parse_rule_2962(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 97i64 | 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2961i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f683 + fn parse_rule_2963(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 133i64 | 148i64 | 170i64 | 173i64 | 188i64 | 236i64 | 423i64 | 427i64 | 451i64 | 510i64 | 565i64 | 594i64 | 616i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(133i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(616i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(148i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(173i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(188i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(427i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(170i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(594i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f684 + fn parse_rule_2964(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 483i64 | 572i64 | 618i64 | 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f685 + fn parse_rule_2965(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 483i64 | 572i64 | 577i64 | 618i64 | 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(577i64, &mut branch_matches, &mut has_children); + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2964i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f686 + fn parse_rule_2966(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 65i64 | 514i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(65i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f687 + fn parse_rule_2967(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // grantIdentifier + fn parse_rule_2968(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 775i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2968i64); + } + self.parse_child(775i64, &mut branch_matches, &mut has_children); + self.parse_child(2967i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2968i64); + } + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(2971i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2968i64); + } + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2968i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f688 + fn parse_rule_2969(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f689 + fn parse_rule_2970(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f690 + fn parse_rule_2971(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 775i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f691 + fn parse_rule_2972(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2974i64, &mut branch_matches, &mut has_children); + self.parse_child(2976i64, &mut branch_matches, &mut has_children); + self.parse_child(2972i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2974i64, &mut branch_matches, &mut has_children); + self.parse_child(2976i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // requireList + fn parse_rule_2973(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 63i64 | 259i64 | 559i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2973i64); + } + self.parse_child(2976i64, &mut branch_matches, &mut has_children); + self.parse_child(2972i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f692 + fn parse_rule_2974(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(15i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f693 + fn parse_rule_2975(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 15i64 | 63i64 | 259i64 | 559i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2974i64, &mut branch_matches, &mut has_children); + self.parse_child(2976i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // requireListElement + fn parse_rule_2976(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 63i64 | 259i64 | 559i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2976i64); + } + self.parse_child(63i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2976i64); + } + self.parse_child(259i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2976i64); + } + self.parse_child(559i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // grantOption + fn parse_rule_2977(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 215i64 | 321i64 | 322i64 | 327i64 | 328i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2977i64); + } + self.parse_child(215i64, &mut branch_matches, &mut has_children); + self.parse_child(391i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2977i64); + } + self.parse_child(322i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2977i64); + } + self.parse_child(327i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2977i64); + } + self.parse_child(321i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2977i64); + } + self.parse_child(328i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f694 + fn parse_rule_2978(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(663i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setRole + fn parse_rule_2979(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2979i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2979i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2980i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2979i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(2981i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2979i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(659i64, &mut branch_matches, &mut has_children); + self.parse_child(10i64, &mut branch_matches, &mut has_children); + self.parse_child(2978i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f695 + fn parse_rule_2980(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 369i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f696 + fn parse_rule_2981(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | + 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | + 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | + 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | + 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | + 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | + 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | + 417i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | + 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | + 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | + 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | + 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | + 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | + 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | + 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | + 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f697 + fn parse_rule_2982(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 663i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(663i64, &mut branch_matches, &mut has_children); + self.parse_child(2984i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f698 + fn parse_rule_2983(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2987i64, &mut branch_matches, &mut has_children); + self.parse_child(2983i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2987i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleList + fn parse_rule_2984(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | + 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | + 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2984i64); + } + self.parse_child(2987i64, &mut branch_matches, &mut has_children); + self.parse_child(2983i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f699 + fn parse_rule_2985(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(2987i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f700 + fn parse_rule_2986(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2988i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // role + fn parse_rule_2987(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | + 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | + 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2987i64); + } + self.parse_child(3874i64, &mut branch_matches, &mut has_children); + self.parse_child(2986i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f701 + fn parse_rule_2988(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 746i64 | 792i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(746i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(792i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f702 + fn parse_rule_2989(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3002i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f703 + fn parse_rule_2990(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2997i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableAdministrationStatement + fn parse_rule_2991(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 14i64 | 61i64 | 62i64 | 388i64 | 455i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2991i64); + } + self.parse_child(14i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2992i64, &mut branch_matches, &mut has_children); + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + self.parse_child(2989i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2991i64); + } + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(2995i64, &mut branch_matches, &mut has_children); + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + self.parse_child(2078i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2991i64); + } + self.parse_child(61i64, &mut branch_matches, &mut has_children); + self.parse_child(2996i64, &mut branch_matches, &mut has_children); + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + self.parse_child(2990i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2991i64); + } + self.parse_child(388i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2998i64, &mut branch_matches, &mut has_children); + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(2991i64); + } + self.parse_child(455i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(2999i64, &mut branch_matches, &mut has_children); + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + self.parse_child(2079i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f704 + fn parse_rule_2992(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f705 + fn parse_rule_2993(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64 | 614i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3002i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f706 + fn parse_rule_2994(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64 | 614i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3002i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f707 + fn parse_rule_2995(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f708 + fn parse_rule_2996(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f709 + fn parse_rule_2997(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64 | 431i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f710 + fn parse_rule_2998(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f711 + fn parse_rule_2999(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f712 + fn parse_rule_3000(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(675i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f713 + fn parse_rule_3001(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // histogram + fn parse_rule_3002(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64 | 614i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3002i64); + } + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(674i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(3000i64, &mut branch_matches, &mut has_children); + self.parse_child(3001i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3002i64); + } + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(674i64, &mut branch_matches, &mut has_children); + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f714 + fn parse_rule_3003(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(675i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f715 + fn parse_rule_3004(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // checkOption + fn parse_rule_3005(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 56i64 | 180i64 | 184i64 | 200i64 | 333i64 | 431i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3005i64); + } + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(615i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3005i64); + } + self.parse_child(3006i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f716 + fn parse_rule_3006(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 56i64 | 180i64 | 184i64 | 333i64 | 431i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(184i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(333i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(56i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // repairType + fn parse_rule_3007(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64 | 431i64 | 619i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3007i64); + } + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3007i64); + } + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3007i64); + } + self.parse_child(619i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f717 + fn parse_rule_3008(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3018i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f718 + fn parse_rule_3009(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3824i64, &mut branch_matches, &mut has_children); + self.parse_child(3009i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3824i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // installUninstallStatment + fn parse_rule_3010(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 245i64 | 607i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3010i64); + } + self.parse_child(245i64, &mut branch_matches, &mut has_children); + self.parse_child(410i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(520i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3010i64); + } + self.parse_child(245i64, &mut branch_matches, &mut has_children); + self.parse_child(664i64, &mut branch_matches, &mut has_children); + self.parse_child(3863i64, &mut branch_matches, &mut has_children); + self.parse_child(3008i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3010i64); + } + self.parse_child(607i64, &mut branch_matches, &mut has_children); + self.parse_child(410i64, &mut branch_matches, &mut has_children); + self.parse_child(3823i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3010i64); + } + self.parse_child(607i64, &mut branch_matches, &mut has_children); + self.parse_child(664i64, &mut branch_matches, &mut has_children); + self.parse_child(3824i64, &mut branch_matches, &mut has_children); + self.parse_child(3009i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f719 + fn parse_rule_3011(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3018i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f720 + fn parse_rule_3012(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3824i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // installOptionType + fn parse_rule_3013(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 214i64 | 658i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3013i64); + } + self.parse_child(214i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3013i64); + } + self.parse_child(658i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f721 + fn parse_rule_3014(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3013i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // installSetValue + fn parse_rule_3015(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3015i64); + } + self.parse_child(3014i64, &mut branch_matches, &mut has_children); + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3016i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f722 + fn parse_rule_3016(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 383i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | + 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | + 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | + 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | + 635i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | + 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | + 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | + 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | + 744i64 | 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | + 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f723 + fn parse_rule_3017(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3015i64, &mut branch_matches, &mut has_children); + self.parse_child(3017i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3015i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // installSetValueList + fn parse_rule_3018(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3018i64); + } + self.parse_child(3015i64, &mut branch_matches, &mut has_children); + self.parse_child(3017i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f724 + fn parse_rule_3019(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3015i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setStatement + fn parse_rule_3020(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3020i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3022i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f725 + fn parse_rule_3021(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // startOptionValueList + fn parse_rule_3022(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3022i64); + } + self.parse_child(592i64, &mut branch_matches, &mut has_children); + self.parse_child(3034i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3022i64); + } + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(3021i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3028i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3022i64); + } + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(3029i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(734i64, &mut branch_matches, &mut has_children); + self.parse_child(3026i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3022i64); + } + self.parse_child(3045i64, &mut branch_matches, &mut has_children); + self.parse_child(3043i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3022i64); + } + self.parse_child(3878i64, &mut branch_matches, &mut has_children); + self.parse_child(3051i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f726 + fn parse_rule_3023(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f727 + fn parse_rule_3024(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 382i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(382i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f728 + fn parse_rule_3025(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 406i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f729 + fn parse_rule_3026(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3753i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f730 + fn parse_rule_3027(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f731 + fn parse_rule_3028(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 382i64 | 406i64 | 782i64 | 784i64 | 786i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(3026i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(3026i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(382i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f732 + fn parse_rule_3029(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f733 + fn parse_rule_3030(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f734 + fn parse_rule_3031(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 406i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(3029i64, &mut branch_matches, &mut has_children); + self.parse_child(590i64, &mut branch_matches, &mut has_children); + self.parse_child(734i64, &mut branch_matches, &mut has_children); + self.parse_child(3026i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f735 + fn parse_rule_3032(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3039i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f736 + fn parse_rule_3033(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3037i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // transactionCharacteristics + fn parse_rule_3034(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 258i64 | 435i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3034i64); + } + self.parse_child(3037i64, &mut branch_matches, &mut has_children); + self.parse_child(3032i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3034i64); + } + self.parse_child(3039i64, &mut branch_matches, &mut has_children); + self.parse_child(3033i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f737 + fn parse_rule_3035(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3039i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f738 + fn parse_rule_3036(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3037i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // transactionAccessMode + fn parse_rule_3037(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 435i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3037i64); + } + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(3038i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f739 + fn parse_rule_3038(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 386i64 | 649i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(649i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // isolationLevel + fn parse_rule_3039(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 258i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3039i64); + } + self.parse_child(258i64, &mut branch_matches, &mut has_children); + self.parse_child(274i64, &mut branch_matches, &mut has_children); + self.parse_child(3041i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f740 + fn parse_rule_3040(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 76i64 | 601i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(76i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(601i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f741 + fn parse_rule_3041(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 435i64 | 456i64 | 500i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(456i64, &mut branch_matches, &mut has_children); + self.parse_child(435i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(3040i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(500i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f742 + fn parse_rule_3042(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3048i64, &mut branch_matches, &mut has_children); + self.parse_child(3042i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3048i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // optionValueListContinued + fn parse_rule_3043(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3043i64); + } + self.parse_child(3042i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f743 + fn parse_rule_3044(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3048i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // optionValueNoOptionType + fn parse_rule_3045(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3045i64); + } + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3053i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3045i64); + } + self.parse_child(3708i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3045i64); + } + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3045i64); + } + self.parse_child(3050i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3053i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3045i64); + } + self.parse_child(356i64, &mut branch_matches, &mut has_children); + self.parse_child(3047i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f744 + fn parse_rule_3046(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f745 + fn parse_rule_3047(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 756i64 | 763i64 | 781i64 | 784i64 | 790i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + self.parse_child(2096i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // optionValue + fn parse_rule_3048(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3048i64); + } + self.parse_child(3878i64, &mut branch_matches, &mut has_children); + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3053i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3048i64); + } + self.parse_child(3045i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f746 + fn parse_rule_3049(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3880i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setSystemVariable + fn parse_rule_3050(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 745i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3050i64); + } + self.parse_child(745i64, &mut branch_matches, &mut has_children); + self.parse_child(3049i64, &mut branch_matches, &mut has_children); + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // startOptionValueListFollowingOptionType + fn parse_rule_3051(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3051i64); + } + self.parse_child(3052i64, &mut branch_matches, &mut has_children); + self.parse_child(3043i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3051i64); + } + self.parse_child(592i64, &mut branch_matches, &mut has_children); + self.parse_child(3034i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // optionValueFollowingOptionType + fn parse_rule_3052(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3052i64); + } + self.parse_child(3387i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3053i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setExprOrDefault + fn parse_rule_3053(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | + 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | + 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | + 100i64 | 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | + 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | + 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | + 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | + 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | + 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | + 316i64 | 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | + 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 383i64 | 384i64 | 386i64 | 387i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | + 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | + 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | + 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | + 632i64 | 635i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | + 661i64 | 662i64 | 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | + 682i64 | 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 710i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | + 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | + 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | + 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3053i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3053i64); + } + self.parse_child(3054i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3053i64); + } + self.parse_child(3055i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f747 + fn parse_rule_3054(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 32i64 | 128i64 | 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f748 + fn parse_rule_3055(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 487i64 | 710i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(710i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f749 + fn parse_rule_3056(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 487i64 | 710i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3055i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // showStatement + fn parse_rule_3057(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 509i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3057i64); + } + self.parse_child(509i64, &mut branch_matches, &mut has_children); + self.parse_child(3091i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f750 + fn parse_rule_3058(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 22i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(22i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f751 + fn parse_rule_3059(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3801i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f752 + fn parse_rule_3060(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 289i64 | 354i64 | 547i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(354i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(289i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f753 + fn parse_rule_3061(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64 | 251i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(251i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f754 + fn parse_rule_3062(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 316i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f755 + fn parse_rule_3063(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 225i64 | 547i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(547i64, &mut branch_matches, &mut has_children); + self.parse_child(3094i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f756 + fn parse_rule_3064(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 33i64 | 446i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(33i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(446i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f757 + fn parse_rule_3065(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f758 + fn parse_rule_3066(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 251i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f759 + fn parse_rule_3067(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f760 + fn parse_rule_3068(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f761 + fn parse_rule_3069(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f762 + fn parse_rule_3070(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f763 + fn parse_rule_3071(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f764 + fn parse_rule_3072(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 235i64 | 236i64 | 263i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(263i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f765 + fn parse_rule_3073(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 166i64 | 639i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(639i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(166i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f766 + fn parse_rule_3074(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3099i64, &mut branch_matches, &mut has_children); + self.parse_child(3074i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3099i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f767 + fn parse_rule_3075(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3099i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f768 + fn parse_rule_3076(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3099i64, &mut branch_matches, &mut has_children); + self.parse_child(3074i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f769 + fn parse_rule_3077(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 40i64 | 91i64 | 96i64 | 256i64 | 334i64 | 400i64 | 522i64 | 567i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3099i64, &mut branch_matches, &mut has_children); + self.parse_child(3074i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f770 + fn parse_rule_3078(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f771 + fn parse_rule_3079(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f772 + fn parse_rule_3080(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 547i64 | 631i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(631i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f773 + fn parse_rule_3081(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 93i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(93i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f774 + fn parse_rule_3082(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f775 + fn parse_rule_3083(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f776 + fn parse_rule_3084(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 618i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f777 + fn parse_rule_3085(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 109i64 | 170i64 | 206i64 | 422i64 | 574i64 | 594i64 | 618i64 | 636i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(109i64, &mut branch_matches, &mut has_children); + self.parse_child(2180i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(170i64, &mut branch_matches, &mut has_children); + self.parse_child(3797i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(3785i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(3783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(594i64, &mut branch_matches, &mut has_children); + self.parse_child(3787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(636i64, &mut branch_matches, &mut has_children); + self.parse_child(3790i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f778 + fn parse_rule_3086(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3760i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f779 + fn parse_rule_3087(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3092i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f780 + fn parse_rule_3088(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3098i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f781 + fn parse_rule_3089(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(204i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f782 + fn parse_rule_3090(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3878i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f783 + fn parse_rule_3091(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 22i64 | 32i64 | 33i64 | 58i64 | 60i64 | 70i64 | 71i64 | 93i64 | 95i64 | 97i64 | 110i64 | 162i64 | 163i64 | 166i64 | 169i64 | 180i64 | 204i64 | 206i64 | + 214i64 | 216i64 | 235i64 | 236i64 | 263i64 | 284i64 | 316i64 | 387i64 | 408i64 | 421i64 | 422i64 | 424i64 | 425i64 | 426i64 | 446i64 | 502i64 | 514i64 | 547i64 | + 553i64 | 571i64 | 574i64 | 593i64 | 631i64 | 639i64 | 658i64 | 673i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(22i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(110i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3087i64, &mut branch_matches, &mut has_children); + self.parse_child(571i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3089i64, &mut branch_matches, &mut has_children); + self.parse_child(593i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(169i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + self.parse_child(547i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(387i64, &mut branch_matches, &mut has_children); + self.parse_child(571i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(408i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(163i64, &mut branch_matches, &mut has_children); + self.parse_child(3059i64, &mut branch_matches, &mut has_children); + self.parse_child(3060i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3087i64, &mut branch_matches, &mut has_children); + self.parse_child(71i64, &mut branch_matches, &mut has_children); + self.parse_child(3061i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3062i64, &mut branch_matches, &mut has_children); + self.parse_child(289i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(514i64, &mut branch_matches, &mut has_children); + self.parse_child(3063i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3064i64, &mut branch_matches, &mut has_children); + self.parse_child(169i64, &mut branch_matches, &mut has_children); + self.parse_child(3065i64, &mut branch_matches, &mut has_children); + self.parse_child(3067i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3070i64, &mut branch_matches, &mut has_children); + self.parse_child(3072i64, &mut branch_matches, &mut has_children); + self.parse_child(3097i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3088i64, &mut branch_matches, &mut has_children); + self.parse_child(2372i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2281i64, &mut branch_matches, &mut has_children); + self.parse_child(162i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(95i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3073i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(639i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(166i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(426i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(425i64, &mut branch_matches, &mut has_children); + self.parse_child(3076i64, &mut branch_matches, &mut has_children); + self.parse_child(3078i64, &mut branch_matches, &mut has_children); + self.parse_child(2386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3090i64, &mut branch_matches, &mut has_children); + self.parse_child(3080i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3089i64, &mut branch_matches, &mut has_children); + self.parse_child(424i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(70i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(93i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(421i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(216i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(3718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(216i64, &mut branch_matches, &mut has_children); + self.parse_child(3082i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(316i64, &mut branch_matches, &mut has_children); + self.parse_child(547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(97i64, &mut branch_matches, &mut has_children); + self.parse_child(3085i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(547i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(547i64, &mut branch_matches, &mut has_children); + self.parse_child(3086i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(422i64, &mut branch_matches, &mut has_children); + self.parse_child(68i64, &mut branch_matches, &mut has_children); + self.parse_child(3783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(206i64, &mut branch_matches, &mut has_children); + self.parse_child(68i64, &mut branch_matches, &mut has_children); + self.parse_child(3785i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // showCommandType + fn parse_rule_3092(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64 | 204i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3092i64); + } + self.parse_child(204i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3092i64); + } + self.parse_child(180i64, &mut branch_matches, &mut has_children); + self.parse_child(3089i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f784 + fn parse_rule_3093(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + self.parse_child(3089i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // nonBlocking + fn parse_rule_3094(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3094i64); + } + self.parse_child(3095i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3094i64); + } + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f785 + fn parse_rule_3095(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(370i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f786 + fn parse_rule_3096(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3095i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fromOrIn + fn parse_rule_3097(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64 | 251i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3097i64); + } + self.parse_child(203i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3097i64); + } + self.parse_child(251i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // inDb + fn parse_rule_3098(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64 | 251i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3098i64); + } + self.parse_child(3097i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // profileType + fn parse_rule_3099(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 40i64 | 91i64 | 96i64 | 256i64 | 334i64 | 400i64 | 522i64 | 567i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3099i64); + } + self.parse_child(40i64, &mut branch_matches, &mut has_children); + self.parse_child(255i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3099i64); + } + self.parse_child(91i64, &mut branch_matches, &mut has_children); + self.parse_child(568i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3099i64); + } + self.parse_child(400i64, &mut branch_matches, &mut has_children); + self.parse_child(185i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3099i64); + } + self.parse_child(3100i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f787 + fn parse_rule_3100(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 96i64 | 256i64 | 334i64 | 522i64 | 567i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(96i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(256i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(522i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(567i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f788 + fn parse_rule_3101(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3107i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // otherAdministrativeStatement + fn parse_rule_3102(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 33i64 | 47i64 | 196i64 | 266i64 | 281i64 | 510i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3102i64); + } + self.parse_child(33i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3102i64); + } + self.parse_child(47i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(3109i64, &mut branch_matches, &mut has_children); + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(3103i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3102i64); + } + self.parse_child(196i64, &mut branch_matches, &mut has_children); + self.parse_child(2077i64, &mut branch_matches, &mut has_children); + self.parse_child(3106i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3102i64); + } + self.parse_child(266i64, &mut branch_matches, &mut has_children); + self.parse_child(3101i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3102i64); + } + self.parse_child(281i64, &mut branch_matches, &mut has_children); + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(248i64, &mut branch_matches, &mut has_children); + self.parse_child(47i64, &mut branch_matches, &mut has_children); + self.parse_child(3136i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3102i64); + } + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f789 + fn parse_rule_3103(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f790 + fn parse_rule_3104(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3123i64, &mut branch_matches, &mut has_children); + self.parse_child(3104i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f791 + fn parse_rule_3105(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f792 + fn parse_rule_3106(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 136i64 | 163i64 | 165i64 | 208i64 | 225i64 | 289i64 | 389i64 | 421i64 | 430i64 | 445i64 | 515i64 | 547i64 | 571i64 | 574i64 | 617i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3129i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3123i64, &mut branch_matches, &mut has_children); + self.parse_child(3104i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f793 + fn parse_rule_3107(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 84i64 | 430i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(84i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(430i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f794 + fn parse_rule_3108(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 510i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyCacheListOrParts + fn parse_rule_3109(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3109i64); + } + self.parse_child(3111i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3109i64); + } + self.parse_child(3115i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f795 + fn parse_rule_3110(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3114i64, &mut branch_matches, &mut has_children); + self.parse_child(3110i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3114i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyCacheList + fn parse_rule_3111(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3111i64); + } + self.parse_child(3114i64, &mut branch_matches, &mut has_children); + self.parse_child(3110i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f796 + fn parse_rule_3112(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3114i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f797 + fn parse_rule_3113(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3117i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // assignToKeycache + fn parse_rule_3114(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3114i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3113i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // assignToKeycachePartition + fn parse_rule_3115(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3115i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3113i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f798 + fn parse_rule_3116(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3120i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // cacheKeyList + fn parse_rule_3117(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 236i64 | 265i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3117i64); + } + self.parse_child(2645i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3116i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyUsageElement + fn parse_rule_3118(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3118i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3118i64); + } + self.parse_child(420i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f799 + fn parse_rule_3119(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3118i64, &mut branch_matches, &mut has_children); + self.parse_child(3119i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3118i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyUsageList + fn parse_rule_3120(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 420i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3120i64); + } + self.parse_child(3118i64, &mut branch_matches, &mut has_children); + self.parse_child(3119i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f800 + fn parse_rule_3121(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3118i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f801 + fn parse_rule_3122(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3127i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // flushOption + fn parse_rule_3123(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 136i64 | 163i64 | 165i64 | 208i64 | 225i64 | 289i64 | 389i64 | 421i64 | 430i64 | 445i64 | 515i64 | 547i64 | 617i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3123i64); + } + self.parse_child(3124i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3123i64); + } + self.parse_child(3122i64, &mut branch_matches, &mut has_children); + self.parse_child(289i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3123i64); + } + self.parse_child(445i64, &mut branch_matches, &mut has_children); + self.parse_child(289i64, &mut branch_matches, &mut has_children); + self.parse_child(2723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3123i64); + } + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(47i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3123i64); + } + self.parse_child(389i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f802 + fn parse_rule_3124(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 136i64 | 225i64 | 421i64 | 547i64 | 617i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(136i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(421i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(617i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f803 + fn parse_rule_3125(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 430i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(47i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f804 + fn parse_rule_3126(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 389i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(389i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // logType + fn parse_rule_3127(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 163i64 | 165i64 | 208i64 | 515i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3127i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3127i64); + } + self.parse_child(163i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3127i64); + } + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3127i64); + } + self.parse_child(208i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3127i64); + } + self.parse_child(515i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f805 + fn parse_rule_3128(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3132i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // flushTables + fn parse_rule_3129(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3129i64); + } + self.parse_child(3130i64, &mut branch_matches, &mut has_children); + self.parse_child(3128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f806 + fn parse_rule_3130(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 571i64 | 574i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(574i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f807 + fn parse_rule_3131(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3133i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f808 + fn parse_rule_3132(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 645i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(287i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + self.parse_child(3131i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // flushTablesOptions + fn parse_rule_3133(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3133i64); + } + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(179i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3133i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(435i64, &mut branch_matches, &mut has_children); + self.parse_child(287i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f809 + fn parse_rule_3134(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(179i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f810 + fn parse_rule_3135(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // preloadTail + fn parse_rule_3136(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3136i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3144i64, &mut branch_matches, &mut has_children); + self.parse_child(3113i64, &mut branch_matches, &mut has_children); + self.parse_child(3135i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3136i64); + } + self.parse_child(3139i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f811 + fn parse_rule_3137(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f812 + fn parse_rule_3138(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3142i64, &mut branch_matches, &mut has_children); + self.parse_child(3138i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // preloadList + fn parse_rule_3139(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3139i64); + } + self.parse_child(3142i64, &mut branch_matches, &mut has_children); + self.parse_child(3138i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f813 + fn parse_rule_3140(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f814 + fn parse_rule_3141(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // preloadKeys + fn parse_rule_3142(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3142i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3113i64, &mut branch_matches, &mut has_children); + self.parse_child(3141i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f815 + fn parse_rule_3143(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + self.parse_child(270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // adminPartition + fn parse_rule_3144(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3144i64); + } + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2139i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resourceGroupManagement + fn parse_rule_3145(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64 | 97i64 | 148i64 | 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3145i64); + } + self.parse_child(3149i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3145i64); + } + self.parse_child(3160i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3145i64); + } + self.parse_child(3162i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3145i64); + } + self.parse_child(3167i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f816 + fn parse_rule_3146(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f817 + fn parse_rule_3147(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3157i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f818 + fn parse_rule_3148(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3158i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createResourceGroup + fn parse_rule_3149(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 97i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3149i64); + } + self.parse_child(97i64, &mut branch_matches, &mut has_children); + self.parse_child(709i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(599i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(3150i64, &mut branch_matches, &mut has_children); + self.parse_child(3146i64, &mut branch_matches, &mut has_children); + self.parse_child(3147i64, &mut branch_matches, &mut has_children); + self.parse_child(3148i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f819 + fn parse_rule_3150(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 618i64 | 710i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(710i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f820 + fn parse_rule_3151(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3155i64, &mut branch_matches, &mut has_children); + self.parse_child(3151i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3155i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resourceGroupVcpuList + fn parse_rule_3152(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 711i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3152i64); + } + self.parse_child(711i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(3155i64, &mut branch_matches, &mut has_children); + self.parse_child(3151i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f821 + fn parse_rule_3153(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64 | 787i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3155i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f822 + fn parse_rule_3154(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(773i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // vcpuNumOrRange + fn parse_rule_3155(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 787i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3155i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(3154i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f823 + fn parse_rule_3156(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 773i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(773i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resourceGroupPriority + fn parse_rule_3157(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 708i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3157i64); + } + self.parse_child(708i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resourceGroupEnableDisable + fn parse_rule_3158(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 140i64 | 156i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3158i64); + } + self.parse_child(156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3158i64); + } + self.parse_child(140i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f824 + fn parse_rule_3159(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(198i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterResourceGroup + fn parse_rule_3160(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 11i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3160i64); + } + self.parse_child(11i64, &mut branch_matches, &mut has_children); + self.parse_child(709i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3825i64, &mut branch_matches, &mut has_children); + self.parse_child(3146i64, &mut branch_matches, &mut has_children); + self.parse_child(3147i64, &mut branch_matches, &mut has_children); + self.parse_child(3148i64, &mut branch_matches, &mut has_children); + self.parse_child(3159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f825 + fn parse_rule_3161(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setResourceGroup + fn parse_rule_3162(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3162i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(709i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3161i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f826 + fn parse_rule_3163(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f827 + fn parse_rule_3164(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(3164i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // threadIdList + fn parse_rule_3165(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3165i64); + } + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(3164i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f828 + fn parse_rule_3166(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dropResourceGroup + fn parse_rule_3167(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 148i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3167i64); + } + self.parse_child(148i64, &mut branch_matches, &mut has_children); + self.parse_child(709i64, &mut branch_matches, &mut has_children); + self.parse_child(217i64, &mut branch_matches, &mut has_children); + self.parse_child(3825i64, &mut branch_matches, &mut has_children); + self.parse_child(3159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // utilityStatement + fn parse_rule_3168(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 134i64 | 135i64 | 178i64 | 222i64 | 620i64 | 714i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3168i64); + } + self.parse_child(3175i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3168i64); + } + self.parse_child(3171i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3168i64); + } + self.parse_child(3187i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3168i64); + } + self.parse_child(3188i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3168i64); + } + self.parse_child(3189i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f829 + fn parse_rule_3169(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 714i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3189i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f830 + fn parse_rule_3170(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3173i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // describeStatement + fn parse_rule_3171(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 134i64 | 135i64 | 178i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3171i64); + } + self.parse_child(3172i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3170i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f831 + fn parse_rule_3172(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 134i64 | 135i64 | 178i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(178i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(135i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(134i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f832 + fn parse_rule_3173(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 782i64 | 784i64 | 786i64 | 790i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f833 + fn parse_rule_3174(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3182i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // explainStatement + fn parse_rule_3175(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 134i64 | 135i64 | 178i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3175i64); + } + self.parse_child(3176i64, &mut branch_matches, &mut has_children); + self.parse_child(3174i64, &mut branch_matches, &mut has_children); + self.parse_child(3183i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f834 + fn parse_rule_3176(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 134i64 | 135i64 | 178i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(178i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(135i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(134i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f835 + fn parse_rule_3177(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 180i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f836 + fn parse_rule_3178(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 404i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f837 + fn parse_rule_3179(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 201i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(201i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f838 + fn parse_rule_3180(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 14i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(14i64, &mut branch_matches, &mut has_children); + self.parse_child(201i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f839 + fn parse_rule_3181(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 14i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(14i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f840 + fn parse_rule_3182(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 14i64 | 180i64 | 201i64 | 404i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(201i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(14i64, &mut branch_matches, &mut has_children); + self.parse_child(201i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(14i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // explainableStatement + fn parse_rule_3183(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 133i64 | 200i64 | 242i64 | 458i64 | 497i64 | 574i64 | 614i64 | 626i64 | 645i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3183i64); + } + self.parse_child(2461i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3183i64); + } + self.parse_child(3184i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3183i64); + } + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(84i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f841 + fn parse_rule_3184(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 133i64 | 242i64 | 458i64 | 614i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2366i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2400i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2457i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2656i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f842 + fn parse_rule_3185(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 133i64 | 242i64 | 458i64 | 614i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3184i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f843 + fn parse_rule_3186(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(84i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // helpCommand + fn parse_rule_3187(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 222i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3187i64); + } + self.parse_child(222i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // useCommand + fn parse_rule_3188(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 620i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3188i64); + } + self.parse_child(620i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // restartServer + fn parse_rule_3189(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 714i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3189i64); + } + self.parse_child(714i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f844 + fn parse_rule_3190(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3198i64, &mut branch_matches, &mut has_children); + self.parse_child(3190i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3198i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // expr + fn parse_rule_3191(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3191i64); + } + self.parse_child(3193i64, &mut branch_matches, &mut has_children); + self.parse_child(3190i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f845 + fn parse_rule_3192(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(257i64, &mut branch_matches, &mut has_children); + self.parse_child(3195i64, &mut branch_matches, &mut has_children); + self.parse_child(3194i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f846 + fn parse_rule_3193(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3202i64, &mut branch_matches, &mut has_children); + self.parse_child(3192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(371i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f847 + fn parse_rule_3194(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 183i64 | 596i64 | 610i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(596i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(183i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(610i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f848 + fn parse_rule_3195(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3407i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f849 + fn parse_rule_3196(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 257i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(257i64, &mut branch_matches, &mut has_children); + self.parse_child(3195i64, &mut branch_matches, &mut has_children); + self.parse_child(3194i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f850 + fn parse_rule_3197(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(371i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f851 + fn parse_rule_3198(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 15i64 | 394i64 | 654i64 | 770i64 | 772i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3199i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(654i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3200i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f852 + fn parse_rule_3199(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 15i64 | 770i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(15i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(770i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f853 + fn parse_rule_3200(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 394i64 | 772i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(772i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f854 + fn parse_rule_3201(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3203i64, &mut branch_matches, &mut has_children); + self.parse_child(3201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3203i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // boolPri + fn parse_rule_3202(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | + 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | 419i64 | + 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | + 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | + 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | 636i64 | + 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | 685i64 | + 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | + 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3202i64); + } + self.parse_child(3207i64, &mut branch_matches, &mut has_children); + self.parse_child(3201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f855 + fn parse_rule_3203(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 257i64 | 763i64 | 764i64 | 765i64 | 768i64 | 769i64 | 776i64 | 777i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(257i64, &mut branch_matches, &mut has_children); + self.parse_child(3195i64, &mut branch_matches, &mut has_children); + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3205i64, &mut branch_matches, &mut has_children); + self.parse_child(3204i64, &mut branch_matches, &mut has_children); + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3205i64, &mut branch_matches, &mut has_children); + self.parse_child(3207i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f856 + fn parse_rule_3204(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 10i64 | 16i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(10i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(16i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // compOp + fn parse_rule_3205(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 763i64 | 764i64 | 765i64 | 768i64 | 769i64 | 776i64 | 777i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(777i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(764i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(768i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(769i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3205i64); + } + self.parse_child(776i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f857 + fn parse_rule_3206(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // predicate + fn parse_rule_3207(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | + 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | 419i64 | + 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | + 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | + 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | 636i64 | + 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | 685i64 | + 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | + 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3207i64); + } + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(3206i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f858 + fn parse_rule_3208(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(668i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f859 + fn parse_rule_3209(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 733i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(733i64, &mut branch_matches, &mut has_children); + self.parse_child(3208i64, &mut branch_matches, &mut has_children); + self.parse_child(3414i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f860 + fn parse_rule_3210(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 30i64 | 251i64 | 275i64 | 371i64 | 444i64 | 521i64 | 733i64 | 800i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3195i64, &mut branch_matches, &mut has_children); + self.parse_child(3212i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(733i64, &mut branch_matches, &mut has_children); + self.parse_child(3208i64, &mut branch_matches, &mut has_children); + self.parse_child(3414i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(521i64, &mut branch_matches, &mut has_children); + self.parse_child(275i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f861 + fn parse_rule_3211(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(168i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // predicateOperations + fn parse_rule_3212(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 30i64 | 251i64 | 275i64 | 444i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3212i64); + } + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(3213i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3212i64); + } + self.parse_child(30i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(15i64, &mut branch_matches, &mut has_children); + self.parse_child(3207i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3212i64); + } + self.parse_child(275i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + self.parse_child(3211i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3212i64); + } + self.parse_child(444i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f862 + fn parse_rule_3213(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f863 + fn parse_rule_3214(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 168i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(168i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f864 + fn parse_rule_3215(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3217i64, &mut branch_matches, &mut has_children); + self.parse_child(3215i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3217i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // bitExpr + fn parse_rule_3216(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | + 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | 419i64 | + 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | + 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | + 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | 636i64 | + 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | 685i64 | + 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | + 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3216i64); + } + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + self.parse_child(3215i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f865 + fn parse_rule_3217(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 145i64 | 349i64 | 757i64 | 759i64 | 760i64 | 762i64 | 773i64 | 774i64 | 775i64 | 778i64 | 779i64 | 780i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(760i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3218i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3219i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3220i64, &mut branch_matches, &mut has_children); + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3221i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(757i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(759i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f866 + fn parse_rule_3218(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 145i64 | 349i64 | 762i64 | 774i64 | 775i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(762i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(774i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(145i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(349i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f867 + fn parse_rule_3219(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 773i64 | 778i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(778i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f868 + fn parse_rule_3220(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 773i64 | 778i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(778i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f869 + fn parse_rule_3221(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 779i64 | 780i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(779i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(780i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f870 + fn parse_rule_3222(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(761i64, &mut branch_matches, &mut has_children); + self.parse_child(3236i64, &mut branch_matches, &mut has_children); + self.parse_child(3225i64, &mut branch_matches, &mut has_children); + self.parse_child(3222i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(761i64, &mut branch_matches, &mut has_children); + self.parse_child(3236i64, &mut branch_matches, &mut has_children); + self.parse_child(3225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // simpleExpr + fn parse_rule_3223(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | + 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | 419i64 | + 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | + 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | + 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | 636i64 | + 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | 685i64 | + 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | + 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3223i64); + } + self.parse_child(3236i64, &mut branch_matches, &mut has_children); + self.parse_child(3225i64, &mut branch_matches, &mut has_children); + self.parse_child(3222i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f871 + fn parse_rule_3224(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 761i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(761i64, &mut branch_matches, &mut has_children); + self.parse_child(3236i64, &mut branch_matches, &mut has_children); + self.parse_child(3225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f872 + fn parse_rule_3225(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(69i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f873 + fn parse_rule_3226(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | + 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | 419i64 | + 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | + 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | + 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | 636i64 | + 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | 685i64 | + 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | + 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3236i64, &mut branch_matches, &mut has_children); + self.parse_child(3225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f874 + fn parse_rule_3227(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 69i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(69i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f875 + fn parse_rule_3228(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f876 + fn parse_rule_3229(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f877 + fn parse_rule_3230(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3320i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f878 + fn parse_rule_3231(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3246i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f879 + fn parse_rule_3232(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f880 + fn parse_rule_3233(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 642i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3391i64, &mut branch_matches, &mut has_children); + self.parse_child(3392i64, &mut branch_matches, &mut has_children); + self.parse_child(3233i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3391i64, &mut branch_matches, &mut has_children); + self.parse_child(3392i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f881 + fn parse_rule_3234(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3393i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f882 + fn parse_rule_3235(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3248i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // simpleExprBody + fn parse_rule_3236(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | + 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | 419i64 | + 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | + 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | + 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | 636i64 | + 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | 685i64 | + 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | + 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | + 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | + 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3382i64, &mut branch_matches, &mut has_children); + self.parse_child(3228i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(754i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3294i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3298i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3240i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3408i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3229i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(2623i64, &mut branch_matches, &mut has_children); + self.parse_child(2496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(752i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(747i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(320i64, &mut branch_matches, &mut has_children); + self.parse_child(3315i64, &mut branch_matches, &mut has_children); + self.parse_child(7i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(3230i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(52i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(21i64, &mut branch_matches, &mut has_children); + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(843i64, &mut branch_matches, &mut has_children); + self.parse_child(3241i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(113i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(52i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3398i64, &mut branch_matches, &mut has_children); + self.parse_child(3231i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(51i64, &mut branch_matches, &mut has_children); + self.parse_child(3232i64, &mut branch_matches, &mut has_children); + self.parse_child(3233i64, &mut branch_matches, &mut has_children); + self.parse_child(3234i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(94i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3398i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(94i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(626i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + self.parse_child(778i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3377i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3329i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3236i64); + } + self.parse_child(3773i64, &mut branch_matches, &mut has_children); + self.parse_child(3235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f883 + fn parse_rule_3237(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 756i64 | 763i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f884 + fn parse_rule_3238(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 672i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3294i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f885 + fn parse_rule_3239(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 678i64 | 679i64 | 681i64 | 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 692i64 | 694i64 | 696i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3298i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f886 + fn parse_rule_3240(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 758i64 | 773i64 | 778i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(778i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f887 + fn parse_rule_3241(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(247i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f888 + fn parse_rule_3242(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3617i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f889 + fn parse_rule_3243(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 52i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(52i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(21i64, &mut branch_matches, &mut has_children); + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(843i64, &mut branch_matches, &mut has_children); + self.parse_child(3241i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(113i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f890 + fn parse_rule_3244(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 52i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(52i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(21i64, &mut branch_matches, &mut has_children); + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(843i64, &mut branch_matches, &mut has_children); + self.parse_child(3241i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(113i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f891 + fn parse_rule_3245(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 642i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3391i64, &mut branch_matches, &mut has_children); + self.parse_child(3392i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // arrayCast + fn parse_rule_3246(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 731i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3246i64); + } + self.parse_child(731i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f892 + fn parse_rule_3247(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 731i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(731i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // jsonOperator + fn parse_rule_3248(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 766i64 | 767i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3248i64); + } + self.parse_child(766i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3248i64); + } + self.parse_child(767i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f893 + fn parse_rule_3249(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 766i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(766i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f894 + fn parse_rule_3250(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 767i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(767i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f895 + fn parse_rule_3251(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(143i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f896 + fn parse_rule_3252(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f897 + fn parse_rule_3253(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f898 + fn parse_rule_3254(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f899 + fn parse_rule_3255(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f900 + fn parse_rule_3256(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f901 + fn parse_rule_3257(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f902 + fn parse_rule_3258(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f903 + fn parse_rule_3259(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f904 + fn parse_rule_3260(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f905 + fn parse_rule_3261(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f906 + fn parse_rule_3262(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f907 + fn parse_rule_3263(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(499i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f908 + fn parse_rule_3264(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // sumExpr + fn parse_rule_3265(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 26i64 | 35i64 | 36i64 | 38i64 | 95i64 | 218i64 | 326i64 | 345i64 | 548i64 | 551i64 | 564i64 | 632i64 | 635i64 | 666i64 | 667i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(26i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3251i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3252i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(3268i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3253i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(3313i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(95i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2722i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3254i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(95i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3274i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3255i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(345i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3251i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3256i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(326i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3251i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3257i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(551i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3258i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(632i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3259i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(548i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3260i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(635i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3261i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(564i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3251i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3265i64); + } + self.parse_child(218i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3251i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + self.parse_child(2374i64, &mut branch_matches, &mut has_children); + self.parse_child(3263i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3264i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f909 + fn parse_rule_3266(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f910 + fn parse_rule_3267(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f911 + fn parse_rule_3268(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 35i64 | 36i64 | 38i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(35i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(36i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(38i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f912 + fn parse_rule_3269(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f913 + fn parse_rule_3270(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f914 + fn parse_rule_3271(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 666i64 | 667i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3313i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f915 + fn parse_rule_3272(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f916 + fn parse_rule_3273(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f917 + fn parse_rule_3274(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | + 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | + 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | + 100i64 | 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | + 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 143i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | + 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 218i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | + 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | + 337i64 | 340i64 | 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | + 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | + 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | + 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | + 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | + 632i64 | 635i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | + 661i64 | 662i64 | 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | + 682i64 | 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | + 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | + 743i64 | 744i64 | 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 775i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | + 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | + 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | + 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2722i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(143i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f918 + fn parse_rule_3275(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f919 + fn parse_rule_3276(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f920 + fn parse_rule_3277(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f921 + fn parse_rule_3278(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f922 + fn parse_rule_3279(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f923 + fn parse_rule_3280(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f924 + fn parse_rule_3281(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f925 + fn parse_rule_3282(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f926 + fn parse_rule_3283(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f927 + fn parse_rule_3284(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f928 + fn parse_rule_3285(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f929 + fn parse_rule_3286(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f930 + fn parse_rule_3287(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f931 + fn parse_rule_3288(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f932 + fn parse_rule_3289(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f933 + fn parse_rule_3290(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f934 + fn parse_rule_3291(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 499i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(499i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f935 + fn parse_rule_3292(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f936 + fn parse_rule_3293(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // groupingOperation + fn parse_rule_3294(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 672i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3294i64); + } + self.parse_child(672i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f937 + fn parse_rule_3295(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3307i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f938 + fn parse_rule_3296(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3310i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f939 + fn parse_rule_3297(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3302i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowFunctionCall + fn parse_rule_3298(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 678i64 | 679i64 | 681i64 | 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 692i64 | 694i64 | 696i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3298i64); + } + self.parse_child(3299i64, &mut branch_matches, &mut has_children); + self.parse_child(3876i64, &mut branch_matches, &mut has_children); + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3298i64); + } + self.parse_child(688i64, &mut branch_matches, &mut has_children); + self.parse_child(3414i64, &mut branch_matches, &mut has_children); + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3298i64); + } + self.parse_child(3300i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3295i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3296i64, &mut branch_matches, &mut has_children); + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3298i64); + } + self.parse_child(3301i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + self.parse_child(3296i64, &mut branch_matches, &mut has_children); + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3298i64); + } + self.parse_child(687i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3297i64, &mut branch_matches, &mut has_children); + self.parse_child(3296i64, &mut branch_matches, &mut has_children); + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f940 + fn parse_rule_3299(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 678i64 | 679i64 | 692i64 | 694i64 | 696i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(696i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(694i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(679i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(678i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(692i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f941 + fn parse_rule_3300(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 684i64 | 686i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(686i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(684i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f942 + fn parse_rule_3301(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 681i64 | 685i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(681i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(685i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f943 + fn parse_rule_3302(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 191i64 | 268i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(268i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f944 + fn parse_rule_3303(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3302i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowingClause + fn parse_rule_3304(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 691i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3304i64); + } + self.parse_child(691i64, &mut branch_matches, &mut has_children); + self.parse_child(3305i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f945 + fn parse_rule_3305(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3826i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2522i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f946 + fn parse_rule_3306(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // leadLagInfo + fn parse_rule_3307(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3307i64); + } + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3308i64, &mut branch_matches, &mut has_children); + self.parse_child(3306i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f947 + fn parse_rule_3308(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 746i64 | 754i64 | 781i64 | 783i64 | 784i64 | 785i64 | 787i64 | 788i64 | + 791i64 | 792i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | + 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | + 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(754i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f948 + fn parse_rule_3309(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // nullTreatment + fn parse_rule_3310(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64 | 695i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3310i64); + } + self.parse_child(3311i64, &mut branch_matches, &mut has_children); + self.parse_child(689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f949 + fn parse_rule_3311(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 232i64 | 695i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(695i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(232i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f950 + fn parse_rule_3312(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // jsonFunction + fn parse_rule_3313(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 666i64 | 667i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3313i64); + } + self.parse_child(667i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3312i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3313i64); + } + self.parse_child(666i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3314i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + self.parse_child(3312i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // inSumExpr + fn parse_rule_3314(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 10i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | + 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | + 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | + 100i64 | 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | + 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | + 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | + 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | + 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | + 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | + 316i64 | 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | + 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | + 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | + 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | + 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | + 635i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | + 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | + 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | + 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | + 744i64 | 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | + 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3314i64); + } + self.parse_child(2722i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identListArg + fn parse_rule_3315(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3315i64); + } + self.parse_child(3317i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3315i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3317i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f951 + fn parse_rule_3316(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(3316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identList + fn parse_rule_3317(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3317i64); + } + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + self.parse_child(3316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f952 + fn parse_rule_3318(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f953 + fn parse_rule_3319(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(176i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fulltextOptions + fn parse_rule_3320(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 251i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3320i64); + } + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(41i64, &mut branch_matches, &mut has_children); + self.parse_child(346i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3320i64); + } + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(359i64, &mut branch_matches, &mut has_children); + self.parse_child(267i64, &mut branch_matches, &mut has_children); + self.parse_child(346i64, &mut branch_matches, &mut has_children); + self.parse_child(3319i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3320i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(176i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f954 + fn parse_rule_3321(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(430i64, &mut branch_matches, &mut has_children); + self.parse_child(176i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f955 + fn parse_rule_3322(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f956 + fn parse_rule_3323(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f957 + fn parse_rule_3324(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3324i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f958 + fn parse_rule_3325(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f959 + fn parse_rule_3326(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3353i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f960 + fn parse_rule_3327(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f961 + fn parse_rule_3328(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // runtimeFunctionCall + fn parse_rule_3329(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 5i64 | 19i64 | 58i64 | 60i64 | 67i64 | 70i64 | 90i64 | 100i64 | 105i64 | 108i64 | 109i64 | 114i64 | 115i64 | 116i64 | 122i64 | 182i64 | 201i64 | 211i64 | + 213i64 | 229i64 | 231i64 | 242i64 | 247i64 | 272i64 | 279i64 | 337i64 | 343i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 372i64 | 382i64 | 406i64 | 411i64 | + 412i64 | 414i64 | 429i64 | 457i64 | 458i64 | 476i64 | 478i64 | 485i64 | 495i64 | 558i64 | 563i64 | 569i64 | 583i64 | 584i64 | 585i64 | 586i64 | 595i64 | 597i64 | + 618i64 | 622i64 | 623i64 | 624i64 | 626i64 | 640i64 | 641i64 | 656i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + self.parse_child(3322i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(105i64, &mut branch_matches, &mut has_children); + self.parse_child(3323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(116i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(122i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(229i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(242i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3324i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(850i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(3332i64, &mut branch_matches, &mut has_children); + self.parse_child(2624i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(272i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(343i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(350i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(478i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(495i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(583i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3325i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(3366i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(618i64, &mut branch_matches, &mut has_children); + self.parse_child(3876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(626i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(656i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(3336i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3337i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(100i64, &mut branch_matches, &mut has_children); + self.parse_child(3323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(108i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(3338i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(182i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(213i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3365i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(372i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(414i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(3370i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(569i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(3339i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3411i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(622i64, &mut branch_matches, &mut has_children); + self.parse_child(3323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(624i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(623i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(19i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 34 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(58i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 35 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(67i64, &mut branch_matches, &mut has_children); + self.parse_child(3412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 36 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(70i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 37 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(109i64, &mut branch_matches, &mut has_children); + self.parse_child(3876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 38 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(231i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 39 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(201i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3327i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 40 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(337i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 41 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(349i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 42 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(382i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 43 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 44 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(429i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 45 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(457i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 46 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(458i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 47 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(476i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 48 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(485i64, &mut branch_matches, &mut has_children); + self.parse_child(3876i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 49 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(597i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 50 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(640i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3328i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 51 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(641i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 52 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(641i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3349i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 53 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3329i64); + } + self.parse_child(3350i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f962 + fn parse_rule_3330(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f963 + fn parse_rule_3331(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f964 + fn parse_rule_3332(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(851i64, &mut branch_matches, &mut has_children); + self.parse_child(3398i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f965 + fn parse_rule_3333(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 851i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(851i64, &mut branch_matches, &mut has_children); + self.parse_child(3398i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f966 + fn parse_rule_3334(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 850i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(850i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(3332i64, &mut branch_matches, &mut has_children); + self.parse_child(2624i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f967 + fn parse_rule_3335(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f968 + fn parse_rule_3336(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 5i64 | 558i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(5i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(558i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f969 + fn parse_rule_3337(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(247i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f970 + fn parse_rule_3338(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 114i64 | 115i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(114i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(115i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f971 + fn parse_rule_3339(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 584i64 | 585i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(584i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(585i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f972 + fn parse_rule_3340(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f973 + fn parse_rule_3341(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 382i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(382i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f974 + fn parse_rule_3342(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 406i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f975 + fn parse_rule_3343(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f976 + fn parse_rule_3344(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(3616i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f977 + fn parse_rule_3345(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(3616i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f978 + fn parse_rule_3346(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 274i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f979 + fn parse_rule_3347(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f980 + fn parse_rule_3348(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 274i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f981 + fn parse_rule_3349(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(3616i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3344i64, &mut branch_matches, &mut has_children); + self.parse_child(3347i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // geometryFunction + fn parse_rule_3350(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 90i64 | 211i64 | 279i64 | 351i64 | 352i64 | 353i64 | 411i64 | 412i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(90i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(211i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2362i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(279i64, &mut branch_matches, &mut has_children); + self.parse_child(3412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(351i64, &mut branch_matches, &mut has_children); + self.parse_child(3412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(352i64, &mut branch_matches, &mut has_children); + self.parse_child(3412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(353i64, &mut branch_matches, &mut has_children); + self.parse_child(3412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(411i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3350i64); + } + self.parse_child(412i64, &mut branch_matches, &mut has_children); + self.parse_child(3412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f982 + fn parse_rule_3351(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 90i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(90i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f983 + fn parse_rule_3352(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3354i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // timeFunctionParameters + fn parse_rule_3353(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3353i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3352i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fractionalPrecision + fn parse_rule_3354(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 787i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3354i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f984 + fn parse_rule_3355(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 787i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // weightStringLevels + fn parse_rule_3356(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 274i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3356i64); + } + self.parse_child(274i64, &mut branch_matches, &mut has_children); + self.parse_child(3359i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f985 + fn parse_rule_3357(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3361i64, &mut branch_matches, &mut has_children); + self.parse_child(3357i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3361i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f986 + fn parse_rule_3358(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3361i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f987 + fn parse_rule_3359(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(773i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3361i64, &mut branch_matches, &mut has_children); + self.parse_child(3357i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f988 + fn parse_rule_3360(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3364i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // weightStringLevelListItem + fn parse_rule_3361(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3361i64); + } + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(3360i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f989 + fn parse_rule_3362(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 18i64 | 134i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(18i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(134i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f990 + fn parse_rule_3363(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(476i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f991 + fn parse_rule_3364(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 18i64 | 134i64 | 476i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3362i64, &mut branch_matches, &mut has_children); + self.parse_child(3363i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(476i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dateTimeTtype + fn parse_rule_3365(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 113i64 | 116i64 | 583i64 | 586i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3365i64); + } + self.parse_child(116i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3365i64); + } + self.parse_child(586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3365i64); + } + self.parse_child(113i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3365i64); + } + self.parse_child(583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // trimFunction + fn parse_rule_3366(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 595i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3366i64); + } + self.parse_child(595i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3369i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f992 + fn parse_rule_3367(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f993 + fn parse_rule_3368(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f994 + fn parse_rule_3369(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 43i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | + 54i64 | 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | + 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | + 100i64 | 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | + 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | + 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | + 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | + 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 269i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | + 337i64 | 340i64 | 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | + 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | + 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | + 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 591i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | + 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | + 631i64 | 632i64 | 635i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | + 660i64 | 661i64 | 662i64 | 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | + 681i64 | 682i64 | 684i64 | 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | + 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | + 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | + 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | + 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | + 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | + 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3367i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(269i64, &mut branch_matches, &mut has_children); + self.parse_child(3232i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(591i64, &mut branch_matches, &mut has_children); + self.parse_child(3232i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(43i64, &mut branch_matches, &mut has_children); + self.parse_child(3232i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // substringFunction + fn parse_rule_3370(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 563i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3370i64); + } + self.parse_child(563i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3375i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f995 + fn parse_rule_3371(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f996 + fn parse_rule_3372(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f997 + fn parse_rule_3373(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f998 + fn parse_rule_3374(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f999 + fn parse_rule_3375(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64 | 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3371i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(203i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3373i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1000 + fn parse_rule_3376(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3379i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // functionCall + fn parse_rule_3377(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3377i64); + } + self.parse_child(3827i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3376i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3377i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(2362i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1001 + fn parse_rule_3378(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3381i64, &mut branch_matches, &mut has_children); + self.parse_child(3378i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3381i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // udfExprList + fn parse_rule_3379(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3379i64); + } + self.parse_child(3381i64, &mut branch_matches, &mut has_children); + self.parse_child(3378i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1002 + fn parse_rule_3380(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3381i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // udfExpr + fn parse_rule_3381(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3381i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(2581i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // variable + fn parse_rule_3382(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 745i64 | 746i64 | 792i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3382i64); + } + self.parse_child(3383i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3382i64); + } + self.parse_child(3386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // userVariable + fn parse_rule_3383(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 746i64 | 792i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3383i64); + } + self.parse_child(746i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3383i64); + } + self.parse_child(792i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1003 + fn parse_rule_3384(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3879i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1004 + fn parse_rule_3385(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // systemVariable + fn parse_rule_3386(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 745i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3386i64); + } + self.parse_child(745i64, &mut branch_matches, &mut has_children); + self.parse_child(3384i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // internalVariableName + fn parse_rule_3387(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3387i64); + } + self.parse_child(3390i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3387i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1005 + fn parse_rule_3388(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1006 + fn parse_rule_3389(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 19i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 29i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | + 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | + 89i64 | 90i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | + 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | + 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | + 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | + 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | + 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | + 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | + 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | + 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | + 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | + 483i64 | 485i64 | 486i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | + 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | + 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | + 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | + 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | + 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | + 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3873i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1007 + fn parse_rule_3390(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3873i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // whenExpression + fn parse_rule_3391(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 642i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3391i64); + } + self.parse_child(642i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // thenExpression + fn parse_rule_3392(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 582i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3392i64); + } + self.parse_child(582i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // elseExpression + fn parse_rule_3393(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 154i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3393i64); + } + self.parse_child(154i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1008 + fn parse_rule_3394(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1009 + fn parse_rule_3395(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3612i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1010 + fn parse_rule_3396(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(249i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1011 + fn parse_rule_3397(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3869i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // castType + fn parse_rule_3398(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 60i64 | 113i64 | 116i64 | 126i64 | 146i64 | 195i64 | 262i64 | 358i64 | 361i64 | 437i64 | 512i64 | 586i64 | 612i64 | 656i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(3604i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(512i64, &mut branch_matches, &mut has_children); + self.parse_child(3396i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(612i64, &mut branch_matches, &mut has_children); + self.parse_child(3396i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(116i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(113i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(126i64, &mut branch_matches, &mut has_children); + self.parse_child(3397i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(656i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(3605i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3398i64); + } + self.parse_child(195i64, &mut branch_matches, &mut has_children); + self.parse_child(3401i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1012 + fn parse_rule_3399(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 262i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1013 + fn parse_rule_3400(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 146i64 | 437i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3605i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1014 + fn parse_rule_3401(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3870i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1015 + fn parse_rule_3402(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 195i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(195i64, &mut branch_matches, &mut has_children); + self.parse_child(3401i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1016 + fn parse_rule_3403(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // exprList + fn parse_rule_3404(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3404i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1017 + fn parse_rule_3405(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // charset + fn parse_rule_3406(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3406i64); + } + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(506i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3406i64); + } + self.parse_child(58i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // notRule + fn parse_rule_3407(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64 | 800i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3407i64); + } + self.parse_child(371i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3407i64); + } + self.parse_child(800i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // not2Rule + fn parse_rule_3408(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 771i64 | 800i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3408i64); + } + self.parse_child(771i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3408i64); + } + self.parse_child(800i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // interval + fn parse_rule_3409(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 118i64 | 119i64 | 120i64 | 121i64 | 122i64 | 226i64 | 227i64 | 228i64 | 229i64 | 337i64 | 341i64 | 342i64 | 343i64 | 350i64 | 429i64 | 494i64 | 495i64 | 640i64 | + 655i64 | 656i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3409i64); + } + self.parse_child(3411i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3409i64); + } + self.parse_child(3410i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1018 + fn parse_rule_3410(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 118i64 | 119i64 | 120i64 | 121i64 | 226i64 | 227i64 | 228i64 | 341i64 | 342i64 | 494i64 | 655i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(494i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(341i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(342i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(226i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(228i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(227i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(119i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(121i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(120i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(118i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(655i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // intervalTimeStamp + fn parse_rule_3411(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 122i64 | 229i64 | 337i64 | 343i64 | 350i64 | 429i64 | 495i64 | 640i64 | 656i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(337i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(495i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(343i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(229i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(122i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(640i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(350i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(429i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3411i64); + } + self.parse_child(656i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // exprListWithParentheses + fn parse_rule_3412(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3412i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3404i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // exprWithParentheses + fn parse_rule_3413(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3413i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // simpleExprWithParentheses + fn parse_rule_3414(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3414i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3223i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1019 + fn parse_rule_3415(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3418i64, &mut branch_matches, &mut has_children); + self.parse_child(3415i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // orderList + fn parse_rule_3416(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3416i64); + } + self.parse_child(3418i64, &mut branch_matches, &mut has_children); + self.parse_child(3415i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1020 + fn parse_rule_3417(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // orderExpression + fn parse_rule_3418(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3418i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1021 + fn parse_rule_3419(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3422i64, &mut branch_matches, &mut has_children); + self.parse_child(3419i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3422i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // groupList + fn parse_rule_3420(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3420i64); + } + self.parse_child(3422i64, &mut branch_matches, &mut has_children); + self.parse_child(3419i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1022 + fn parse_rule_3421(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3422i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // groupingExpression + fn parse_rule_3422(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3422i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // channel + fn parse_rule_3423(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3423i64); + } + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(57i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1023 + fn parse_rule_3424(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 200i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(57i64, &mut branch_matches, &mut has_children); + self.parse_child(3861i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // compoundStatement + fn parse_rule_3425(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 14i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 47i64 | 48i64 | 50i64 | 51i64 | 53i64 | 54i64 | 55i64 | 56i64 | 57i64 | 61i64 | + 62i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 134i64 | 135i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | + 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 178i64 | 179i64 | 180i64 | + 181i64 | 184i64 | 185i64 | 186i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 201i64 | 202i64 | 204i64 | 206i64 | 207i64 | 208i64 | 210i64 | 211i64 | + 212i64 | 213i64 | 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | + 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 260i64 | 262i64 | 264i64 | 266i64 | 268i64 | 270i64 | 271i64 | 273i64 | 274i64 | 279i64 | + 280i64 | 281i64 | 284i64 | 286i64 | 287i64 | 288i64 | 289i64 | 294i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 388i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 428i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 450i64 | 451i64 | 452i64 | 453i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 469i64 | 470i64 | 472i64 | 473i64 | 474i64 | 475i64 | 476i64 | 477i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | + 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 506i64 | 508i64 | 509i64 | 510i64 | 511i64 | + 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 574i64 | + 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 607i64 | 610i64 | 611i64 | 613i64 | 614i64 | 615i64 | 617i64 | 618i64 | 619i64 | 620i64 | 625i64 | 626i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 644i64 | 645i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(2004i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3426i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3427i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3437i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3441i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3442i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3447i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3448i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3470i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3469i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3502i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3505i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3425i64); + } + self.parse_child(3503i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // returnStatement + fn parse_rule_3426(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 475i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3426i64); + } + self.parse_child(475i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ifStatement + fn parse_rule_3427(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3427i64); + } + self.parse_child(231i64, &mut branch_matches, &mut has_children); + self.parse_child(3429i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + self.parse_child(231i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1024 + fn parse_rule_3428(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3430i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ifBody + fn parse_rule_3429(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3429i64); + } + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3431i64, &mut branch_matches, &mut has_children); + self.parse_child(3428i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1025 + fn parse_rule_3430(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 154i64 | 155i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(155i64, &mut branch_matches, &mut has_children); + self.parse_child(3429i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(154i64, &mut branch_matches, &mut has_children); + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // thenStatement + fn parse_rule_3431(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 582i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3431i64); + } + self.parse_child(582i64, &mut branch_matches, &mut has_children); + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1026 + fn parse_rule_3432(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 14i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 47i64 | 48i64 | 50i64 | 51i64 | 53i64 | 54i64 | 55i64 | 56i64 | 57i64 | 61i64 | + 62i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 134i64 | 135i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | + 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 178i64 | 179i64 | 180i64 | + 181i64 | 184i64 | 185i64 | 186i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 201i64 | 202i64 | 204i64 | 206i64 | 207i64 | 208i64 | 210i64 | 211i64 | + 212i64 | 213i64 | 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | + 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 260i64 | 262i64 | 264i64 | 266i64 | 268i64 | 270i64 | 271i64 | 273i64 | 274i64 | 279i64 | + 280i64 | 281i64 | 284i64 | 286i64 | 287i64 | 288i64 | 289i64 | 294i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 388i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 428i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 450i64 | 451i64 | 452i64 | 453i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 469i64 | 470i64 | 472i64 | 473i64 | 474i64 | 475i64 | 476i64 | 477i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | + 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 506i64 | 508i64 | 509i64 | 510i64 | 511i64 | + 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 574i64 | + 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 607i64 | 610i64 | 611i64 | 613i64 | 614i64 | 615i64 | 617i64 | 618i64 | 619i64 | 620i64 | 625i64 | 626i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 644i64 | 645i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + self.parse_child(755i64, &mut branch_matches, &mut has_children); + self.parse_child(3432i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + self.parse_child(755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // compoundStatementList + fn parse_rule_3433(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 14i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 47i64 | 48i64 | 50i64 | 51i64 | 53i64 | 54i64 | 55i64 | 56i64 | 57i64 | 61i64 | + 62i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 134i64 | 135i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | + 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 178i64 | 179i64 | 180i64 | + 181i64 | 184i64 | 185i64 | 186i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 201i64 | 202i64 | 204i64 | 206i64 | 207i64 | 208i64 | 210i64 | 211i64 | + 212i64 | 213i64 | 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | + 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 260i64 | 262i64 | 264i64 | 266i64 | 268i64 | 270i64 | 271i64 | 273i64 | 274i64 | 279i64 | + 280i64 | 281i64 | 284i64 | 286i64 | 287i64 | 288i64 | 289i64 | 294i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 388i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 428i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 450i64 | 451i64 | 452i64 | 453i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 469i64 | 470i64 | 472i64 | 473i64 | 474i64 | 475i64 | 476i64 | 477i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | + 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 506i64 | 508i64 | 509i64 | 510i64 | 511i64 | + 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 574i64 | + 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 607i64 | 610i64 | 611i64 | 613i64 | 614i64 | 615i64 | 617i64 | 618i64 | 619i64 | 620i64 | 625i64 | 626i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 644i64 | 645i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3433i64); + } + self.parse_child(3432i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1027 + fn parse_rule_3434(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 11i64 | 12i64 | 13i64 | 14i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | + 27i64 | 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 47i64 | 48i64 | 50i64 | 51i64 | 53i64 | 54i64 | 55i64 | 56i64 | 57i64 | 61i64 | + 62i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | + 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 97i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | + 129i64 | 130i64 | 132i64 | 133i64 | 134i64 | 135i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 148i64 | 150i64 | 151i64 | 152i64 | 156i64 | + 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 178i64 | 179i64 | 180i64 | + 181i64 | 184i64 | 185i64 | 186i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 201i64 | 202i64 | 204i64 | 206i64 | 207i64 | 208i64 | 210i64 | 211i64 | + 212i64 | 213i64 | 214i64 | 215i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | + 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 260i64 | 262i64 | 264i64 | 266i64 | 268i64 | 270i64 | 271i64 | 273i64 | 274i64 | 279i64 | + 280i64 | 281i64 | 284i64 | 286i64 | 287i64 | 288i64 | 289i64 | 294i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 388i64 | + 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 428i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 450i64 | 451i64 | 452i64 | 453i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 469i64 | 470i64 | 472i64 | 473i64 | 474i64 | 475i64 | 476i64 | 477i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | + 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 497i64 | 500i64 | 501i64 | 502i64 | 503i64 | 506i64 | 508i64 | 509i64 | 510i64 | 511i64 | + 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 574i64 | + 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 607i64 | 610i64 | 611i64 | 613i64 | 614i64 | 615i64 | 617i64 | 618i64 | 619i64 | 620i64 | 625i64 | 626i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 644i64 | 645i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | + 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | + 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + self.parse_child(755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1028 + fn parse_rule_3435(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 642i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3391i64, &mut branch_matches, &mut has_children); + self.parse_child(3431i64, &mut branch_matches, &mut has_children); + self.parse_child(3435i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3391i64, &mut branch_matches, &mut has_children); + self.parse_child(3431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1029 + fn parse_rule_3436(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3439i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // caseStatement + fn parse_rule_3437(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 51i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3437i64); + } + self.parse_child(51i64, &mut branch_matches, &mut has_children); + self.parse_child(3232i64, &mut branch_matches, &mut has_children); + self.parse_child(3435i64, &mut branch_matches, &mut has_children); + self.parse_child(3436i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + self.parse_child(51i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1030 + fn parse_rule_3438(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 642i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3391i64, &mut branch_matches, &mut has_children); + self.parse_child(3431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // elseStatement + fn parse_rule_3439(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 154i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3439i64); + } + self.parse_child(154i64, &mut branch_matches, &mut has_children); + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1031 + fn parse_rule_3440(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // labeledBlock + fn parse_rule_3441(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | + 73i64 | 74i64 | 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | + 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | + 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3441i64); + } + self.parse_child(3443i64, &mut branch_matches, &mut has_children); + self.parse_child(3446i64, &mut branch_matches, &mut has_children); + self.parse_child(3440i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // unlabeledBlock + fn parse_rule_3442(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 29i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3442i64); + } + self.parse_child(3446i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // label + fn parse_rule_3443(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | + 73i64 | 74i64 | 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | + 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | + 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3443i64); + } + self.parse_child(3819i64, &mut branch_matches, &mut has_children); + self.parse_child(749i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1032 + fn parse_rule_3444(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3453i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1033 + fn parse_rule_3445(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // beginEndBlock + fn parse_rule_3446(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 29i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3446i64); + } + self.parse_child(29i64, &mut branch_matches, &mut has_children); + self.parse_child(3444i64, &mut branch_matches, &mut has_children); + self.parse_child(3445i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // labeledControl + fn parse_rule_3447(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | + 73i64 | 74i64 | 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | + 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | + 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3447i64); + } + self.parse_child(3443i64, &mut branch_matches, &mut has_children); + self.parse_child(3448i64, &mut branch_matches, &mut has_children); + self.parse_child(3440i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // unlabeledControl + fn parse_rule_3448(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 294i64 | 457i64 | 644i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3448i64); + } + self.parse_child(3449i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3448i64); + } + self.parse_child(3450i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3448i64); + } + self.parse_child(3451i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // loopBlock + fn parse_rule_3449(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 294i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3449i64); + } + self.parse_child(294i64, &mut branch_matches, &mut has_children); + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + self.parse_child(294i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // whileDoBlock + fn parse_rule_3450(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 644i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3450i64); + } + self.parse_child(644i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(147i64, &mut branch_matches, &mut has_children); + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + self.parse_child(644i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // repeatUntilBlock + fn parse_rule_3451(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 457i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3451i64); + } + self.parse_child(457i64, &mut branch_matches, &mut has_children); + self.parse_child(3433i64, &mut branch_matches, &mut has_children); + self.parse_child(613i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(159i64, &mut branch_matches, &mut has_children); + self.parse_child(457i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1034 + fn parse_rule_3452(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3455i64, &mut branch_matches, &mut has_children); + self.parse_child(755i64, &mut branch_matches, &mut has_children); + self.parse_child(3452i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3455i64, &mut branch_matches, &mut has_children); + self.parse_child(755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // spDeclarations + fn parse_rule_3453(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3453i64); + } + self.parse_child(3452i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1035 + fn parse_rule_3454(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3455i64, &mut branch_matches, &mut has_children); + self.parse_child(755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // spDeclaration + fn parse_rule_3455(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3455i64); + } + self.parse_child(3457i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3455i64); + } + self.parse_child(3459i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3455i64); + } + self.parse_child(3464i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3455i64); + } + self.parse_child(3468i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1036 + fn parse_rule_3456(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // variableDeclaration + fn parse_rule_3457(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3457i64); + } + self.parse_child(127i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(3592i64, &mut branch_matches, &mut has_children); + self.parse_child(2096i64, &mut branch_matches, &mut has_children); + self.parse_child(3456i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1037 + fn parse_rule_3458(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // conditionDeclaration + fn parse_rule_3459(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3459i64); + } + self.parse_child(127i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(83i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3460i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // spCondition + fn parse_rule_3460(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 526i64 | 783i64 | 785i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3460i64); + } + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3460i64); + } + self.parse_child(3462i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1038 + fn parse_rule_3461(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // sqlstate + fn parse_rule_3462(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 526i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3462i64); + } + self.parse_child(526i64, &mut branch_matches, &mut has_children); + self.parse_child(3461i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1039 + fn parse_rule_3463(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3467i64, &mut branch_matches, &mut has_children); + self.parse_child(3463i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3467i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // handlerDeclaration + fn parse_rule_3464(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3464i64); + } + self.parse_child(127i64, &mut branch_matches, &mut has_children); + self.parse_child(3465i64, &mut branch_matches, &mut has_children); + self.parse_child(219i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(3467i64, &mut branch_matches, &mut has_children); + self.parse_child(3463i64, &mut branch_matches, &mut has_children); + self.parse_child(3425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1040 + fn parse_rule_3465(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 92i64 | 175i64 | 605i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(92i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(175i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(605i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1041 + fn parse_rule_3466(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3467i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // handlerCondition + fn parse_rule_3467(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 525i64 | 526i64 | 527i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | + 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | + 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | + 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | + 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | + 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | + 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 783i64 | 784i64 | 785i64 | + 786i64 | 787i64 | 788i64 | 791i64 | 793i64 | 800i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | + 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | + 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3467i64); + } + self.parse_child(3460i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3467i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3467i64); + } + self.parse_child(527i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3467i64); + } + self.parse_child(3407i64, &mut branch_matches, &mut has_children); + self.parse_child(202i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3467i64); + } + self.parse_child(525i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // cursorDeclaration + fn parse_rule_3468(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 127i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3468i64); + } + self.parse_child(127i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(106i64, &mut branch_matches, &mut has_children); + self.parse_child(200i64, &mut branch_matches, &mut has_children); + self.parse_child(2461i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // iterateStatement + fn parse_rule_3469(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 260i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3469i64); + } + self.parse_child(260i64, &mut branch_matches, &mut has_children); + self.parse_child(3820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // leaveStatement + fn parse_rule_3470(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 271i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3470i64); + } + self.parse_child(271i64, &mut branch_matches, &mut has_children); + self.parse_child(3820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1042 + fn parse_rule_3471(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3474i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // getDiagnostics + fn parse_rule_3472(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 207i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3472i64); + } + self.parse_child(207i64, &mut branch_matches, &mut has_children); + self.parse_child(3471i64, &mut branch_matches, &mut has_children); + self.parse_child(138i64, &mut branch_matches, &mut has_children); + self.parse_child(3479i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1043 + fn parse_rule_3473(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 540i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(540i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1044 + fn parse_rule_3474(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 101i64 | 540i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(101i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(540i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1045 + fn parse_rule_3475(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3481i64, &mut branch_matches, &mut has_children); + self.parse_child(3475i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3481i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1046 + fn parse_rule_3476(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3481i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1047 + fn parse_rule_3477(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3484i64, &mut branch_matches, &mut has_children); + self.parse_child(3477i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1048 + fn parse_rule_3478(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1049 + fn parse_rule_3479(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 83i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | + 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | + 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | + 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3481i64, &mut branch_matches, &mut has_children); + self.parse_child(3475i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(83i64, &mut branch_matches, &mut has_children); + self.parse_child(3480i64, &mut branch_matches, &mut has_children); + self.parse_child(3484i64, &mut branch_matches, &mut has_children); + self.parse_child(3477i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // signalAllowedExpr + fn parse_rule_3480(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | + 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | + 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | + 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 751i64 | 781i64 | 782i64 | + 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3480i64); + } + self.parse_child(3847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3480i64); + } + self.parse_child(3382i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3480i64); + } + self.parse_child(3837i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // statementInformationItem + fn parse_rule_3481(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3481i64); + } + self.parse_child(3482i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1050 + fn parse_rule_3482(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3382i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1051 + fn parse_rule_3483(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 377i64 | 485i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(377i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(485i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // conditionInformationItem + fn parse_rule_3484(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3484i64); + } + self.parse_child(3485i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3486i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1052 + fn parse_rule_3485(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 745i64 | 746i64 | 781i64 | 784i64 | 792i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3382i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1053 + fn parse_rule_3486(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 53i64 | 64i64 | 73i64 | 87i64 | 88i64 | 89i64 | 107i64 | 336i64 | 355i64 | 473i64 | 492i64 | 557i64 | 576i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(473i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // signalInformationItemName + fn parse_rule_3487(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 53i64 | 64i64 | 73i64 | 87i64 | 88i64 | 89i64 | 107i64 | 336i64 | 355i64 | 492i64 | 557i64 | 576i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(64i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(87i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(89i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(88i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(53i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(492i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(576i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(73i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(107i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(336i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3487i64); + } + self.parse_child(355i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1054 + fn parse_rule_3488(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + self.parse_child(3491i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // signalStatement + fn parse_rule_3489(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 511i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3489i64); + } + self.parse_child(511i64, &mut branch_matches, &mut has_children); + self.parse_child(3490i64, &mut branch_matches, &mut has_children); + self.parse_child(3488i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1055 + fn parse_rule_3490(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 526i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3462i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1056 + fn parse_rule_3491(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + self.parse_child(3491i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1057 + fn parse_rule_3492(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1058 + fn parse_rule_3493(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + self.parse_child(3491i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1059 + fn parse_rule_3494(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3497i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1060 + fn parse_rule_3495(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + self.parse_child(3498i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resignalStatement + fn parse_rule_3496(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 469i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3496i64); + } + self.parse_child(469i64, &mut branch_matches, &mut has_children); + self.parse_child(3494i64, &mut branch_matches, &mut has_children); + self.parse_child(3495i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1061 + fn parse_rule_3497(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 526i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3462i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1062 + fn parse_rule_3498(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + self.parse_child(3498i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1063 + fn parse_rule_3499(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1064 + fn parse_rule_3500(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3501i64, &mut branch_matches, &mut has_children); + self.parse_child(3498i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // signalInformationItem + fn parse_rule_3501(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 53i64 | 64i64 | 73i64 | 87i64 | 88i64 | 89i64 | 107i64 | 336i64 | 355i64 | 492i64 | 557i64 | 576i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3501i64); + } + self.parse_child(3487i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3480i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // cursorOpen + fn parse_rule_3502(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 387i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3502i64); + } + self.parse_child(387i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // cursorClose + fn parse_rule_3503(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 66i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3503i64); + } + self.parse_child(66i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1065 + fn parse_rule_3504(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3506i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // cursorFetch + fn parse_rule_3505(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 186i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3505i64); + } + self.parse_child(186i64, &mut branch_matches, &mut has_children); + self.parse_child(3504i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(248i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1066 + fn parse_rule_3506(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(367i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1067 + fn parse_rule_3507(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 203i64 | 367i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3506i64, &mut branch_matches, &mut has_children); + self.parse_child(203i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1068 + fn parse_rule_3508(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(542i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1069 + fn parse_rule_3509(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(160i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // schedule + fn parse_rule_3510(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 21i64 | 171i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3510i64); + } + self.parse_child(21i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3510i64); + } + self.parse_child(171i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + self.parse_child(3409i64, &mut branch_matches, &mut has_children); + self.parse_child(3508i64, &mut branch_matches, &mut has_children); + self.parse_child(3509i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1070 + fn parse_rule_3511(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 542i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(542i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1071 + fn parse_rule_3512(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 160i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(160i64, &mut branch_matches, &mut has_children); + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnDefinition + fn parse_rule_3513(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3513i64); + } + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + self.parse_child(3528i64, &mut branch_matches, &mut has_children); + self.parse_child(2098i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // checkOrReferences + fn parse_rule_3514(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64 | 443i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3514i64); + } + self.parse_child(3516i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3514i64); + } + self.parse_child(3556i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1072 + fn parse_rule_3515(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3516i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // checkConstraint + fn parse_rule_3516(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3516i64); + } + self.parse_child(62i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // constraintEnforcement + fn parse_rule_3517(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64 | 730i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3517i64); + } + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(730i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1073 + fn parse_rule_3518(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3527i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableConstraintDef + fn parse_rule_3519(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64 | 86i64 | 199i64 | 205i64 | 236i64 | 265i64 | 420i64 | 523i64 | 609i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3519i64); + } + self.parse_child(3520i64, &mut branch_matches, &mut has_children); + self.parse_child(2232i64, &mut branch_matches, &mut has_children); + self.parse_child(3574i64, &mut branch_matches, &mut has_children); + self.parse_child(2235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3519i64); + } + self.parse_child(205i64, &mut branch_matches, &mut has_children); + self.parse_child(2646i64, &mut branch_matches, &mut has_children); + self.parse_child(2239i64, &mut branch_matches, &mut has_children); + self.parse_child(3574i64, &mut branch_matches, &mut has_children); + self.parse_child(2236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3519i64); + } + self.parse_child(523i64, &mut branch_matches, &mut has_children); + self.parse_child(2646i64, &mut branch_matches, &mut has_children); + self.parse_child(2239i64, &mut branch_matches, &mut has_children); + self.parse_child(3574i64, &mut branch_matches, &mut has_children); + self.parse_child(2237i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3519i64); + } + self.parse_child(3518i64, &mut branch_matches, &mut has_children); + self.parse_child(3525i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1074 + fn parse_rule_3520(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 236i64 | 265i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1075 + fn parse_rule_3521(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 420i64 | 609i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(420i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(609i64, &mut branch_matches, &mut has_children); + self.parse_child(2646i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1076 + fn parse_rule_3522(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64 | 730i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1077 + fn parse_rule_3523(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1078 + fn parse_rule_3524(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64 | 730i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1079 + fn parse_rule_3525(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64 | 199i64 | 420i64 | 609i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3521i64, &mut branch_matches, &mut has_children); + self.parse_child(2232i64, &mut branch_matches, &mut has_children); + self.parse_child(3574i64, &mut branch_matches, &mut has_children); + self.parse_child(2235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(199i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + self.parse_child(2239i64, &mut branch_matches, &mut has_children); + self.parse_child(3567i64, &mut branch_matches, &mut has_children); + self.parse_child(3556i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3516i64, &mut branch_matches, &mut has_children); + self.parse_child(3523i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1080 + fn parse_rule_3526(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // constraintName + fn parse_rule_3527(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 86i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3527i64); + } + self.parse_child(86i64, &mut branch_matches, &mut has_children); + self.parse_child(3526i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldDefinition + fn parse_rule_3528(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 31i64 | 32i64 | 37i64 | 39i64 | 41i64 | 42i64 | 60i64 | 113i64 | 116i64 | 126i64 | 146i64 | 164i64 | 192i64 | 195i64 | 211i64 | 212i64 | 249i64 | 262i64 | + 279i64 | 290i64 | 291i64 | 293i64 | 330i64 | 331i64 | 332i64 | 351i64 | 352i64 | 353i64 | 358i64 | 361i64 | 378i64 | 379i64 | 411i64 | 412i64 | 437i64 | 501i64 | + 506i64 | 516i64 | 580i64 | 583i64 | 586i64 | 587i64 | 588i64 | 589i64 | 628i64 | 629i64 | 656i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3528i64); + } + self.parse_child(3592i64, &mut branch_matches, &mut has_children); + self.parse_child(3539i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1081 + fn parse_rule_3529(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(209i64, &mut branch_matches, &mut has_children); + self.parse_child(12i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1082 + fn parse_rule_3530(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 209i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(209i64, &mut branch_matches, &mut has_children); + self.parse_child(12i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1083 + fn parse_rule_3531(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3532i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1084 + fn parse_rule_3532(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 554i64 | 637i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(637i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(554i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1085 + fn parse_rule_3533(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3542i64, &mut branch_matches, &mut has_children); + self.parse_child(3533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3542i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1086 + fn parse_rule_3534(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1087 + fn parse_rule_3535(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3552i64, &mut branch_matches, &mut has_children); + self.parse_child(3535i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3552i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1088 + fn parse_rule_3536(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3535i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1089 + fn parse_rule_3537(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3535i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1090 + fn parse_rule_3538(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64 | 69i64 | 209i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2096i64, &mut branch_matches, &mut has_children); + self.parse_child(3529i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + self.parse_child(3531i64, &mut branch_matches, &mut has_children); + self.parse_child(3537i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1091 + fn parse_rule_3539(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2096i64, &mut branch_matches, &mut has_children); + self.parse_child(3529i64, &mut branch_matches, &mut has_children); + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + self.parse_child(3531i64, &mut branch_matches, &mut has_children); + self.parse_child(3537i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1092 + fn parse_rule_3540(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(420i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1093 + fn parse_rule_3541(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnAttribute + fn parse_rule_3542(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 24i64 | 62i64 | 69i64 | 74i64 | 75i64 | 86i64 | 128i64 | 265i64 | 371i64 | 376i64 | 383i64 | 420i64 | 501i64 | 553i64 | 609i64 | 661i64 | 662i64 | 707i64 | + 730i64 | 801i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(2041i64, &mut branch_matches, &mut has_children); + self.parse_child(3867i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(371i64, &mut branch_matches, &mut has_children); + self.parse_child(720i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(3545i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(372i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(24i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(501i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + self.parse_child(627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(3540i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(609i64, &mut branch_matches, &mut has_children); + self.parse_child(3541i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(3697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(74i64, &mut branch_matches, &mut has_children); + self.parse_child(3550i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(553i64, &mut branch_matches, &mut has_children); + self.parse_child(3551i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(707i64, &mut branch_matches, &mut has_children); + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(3518i64, &mut branch_matches, &mut has_children); + self.parse_child(3516i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3542i64); + } + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1094 + fn parse_rule_3543(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(371i64, &mut branch_matches, &mut has_children); + self.parse_child(720i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1095 + fn parse_rule_3544(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1096 + fn parse_rule_3545(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 116i64 | 183i64 | 372i64 | 376i64 | 583i64 | 586i64 | 596i64 | 753i64 | 773i64 | 778i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | + 790i64 | 791i64 | 794i64 | 801i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3849i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(372i64, &mut branch_matches, &mut has_children); + self.parse_child(3326i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1097 + fn parse_rule_3546(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1098 + fn parse_rule_3547(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 707i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(707i64, &mut branch_matches, &mut has_children); + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1099 + fn parse_rule_3548(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 62i64 | 86i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3518i64, &mut branch_matches, &mut has_children); + self.parse_child(3516i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1100 + fn parse_rule_3549(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 371i64 | 730i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnFormat + fn parse_rule_3550(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 152i64 | 192i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3550i64); + } + self.parse_child(192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3550i64); + } + self.parse_child(152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3550i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // storageMedia + fn parse_rule_3551(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 142i64 | 334i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3551i64); + } + self.parse_child(142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3551i64); + } + self.parse_child(334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3551i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // gcolAttribute + fn parse_rule_3552(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 265i64 | 371i64 | 376i64 | 420i64 | 609i64 | 800i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3552i64); + } + self.parse_child(609i64, &mut branch_matches, &mut has_children); + self.parse_child(3541i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3552i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3552i64); + } + self.parse_child(3195i64, &mut branch_matches, &mut has_children); + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3552i64); + } + self.parse_child(3540i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1101 + fn parse_rule_3553(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1102 + fn parse_rule_3554(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(320i64, &mut branch_matches, &mut has_children); + self.parse_child(3557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1103 + fn parse_rule_3555(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3563i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // references + fn parse_rule_3556(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 443i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3556i64); + } + self.parse_child(443i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3553i64, &mut branch_matches, &mut has_children); + self.parse_child(3554i64, &mut branch_matches, &mut has_children); + self.parse_child(3555i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1104 + fn parse_rule_3557(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 204i64 | 402i64 | 513i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(204i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(402i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1105 + fn parse_rule_3558(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 320i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(320i64, &mut branch_matches, &mut has_children); + self.parse_child(3557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1106 + fn parse_rule_3559(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(133i64, &mut branch_matches, &mut has_children); + self.parse_child(3564i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1107 + fn parse_rule_3560(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(133i64, &mut branch_matches, &mut has_children); + self.parse_child(3564i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1108 + fn parse_rule_3561(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(3564i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1109 + fn parse_rule_3562(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(3564i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1110 + fn parse_rule_3563(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 383i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(614i64, &mut branch_matches, &mut has_children); + self.parse_child(3564i64, &mut branch_matches, &mut has_children); + self.parse_child(3559i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(383i64, &mut branch_matches, &mut has_children); + self.parse_child(133i64, &mut branch_matches, &mut has_children); + self.parse_child(3564i64, &mut branch_matches, &mut has_children); + self.parse_child(3561i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // deleteOption + fn parse_rule_3564(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 49i64 | 373i64 | 471i64 | 506i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3564i64); + } + self.parse_child(3565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3564i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3867i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3564i64); + } + self.parse_child(373i64, &mut branch_matches, &mut has_children); + self.parse_child(3i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3564i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1111 + fn parse_rule_3565(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 49i64 | 471i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(471i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(49i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1112 + fn parse_rule_3566(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3569i64, &mut branch_matches, &mut has_children); + self.parse_child(3566i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3569i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyList + fn parse_rule_3567(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3567i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3569i64, &mut branch_matches, &mut has_children); + self.parse_child(3566i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1113 + fn parse_rule_3568(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3569i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyPart + fn parse_rule_3569(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3569i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1114 + fn parse_rule_3570(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3573i64, &mut branch_matches, &mut has_children); + self.parse_child(3570i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3573i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyListWithExpression + fn parse_rule_3571(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3571i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3573i64, &mut branch_matches, &mut has_children); + self.parse_child(3570i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1115 + fn parse_rule_3572(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3573i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyPartOrExpression + fn parse_rule_3573(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 753i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3573i64); + } + self.parse_child(3569i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3573i64); + } + self.parse_child(3413i64, &mut branch_matches, &mut has_children); + self.parse_child(2123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // keyListVariants + fn parse_rule_3574(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3574i64); + } + self.parse_child(3571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3574i64); + } + self.parse_child(3567i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1116 + fn parse_rule_3575(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1117 + fn parse_rule_3576(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3567i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexType + fn parse_rule_3577(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 44i64 | 220i64 | 488i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3577i64); + } + self.parse_child(3578i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1118 + fn parse_rule_3578(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 44i64 | 220i64 | 488i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(44i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(488i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(220i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexOption + fn parse_rule_3579(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 264i64 | 599i64 | 621i64 | 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3579i64); + } + self.parse_child(3580i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3579i64); + } + self.parse_child(3583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // commonIndexOption + fn parse_rule_3580(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 264i64 | 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3580i64); + } + self.parse_child(264i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3580i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3580i64); + } + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1119 + fn parse_rule_3581(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3582i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // visibility + fn parse_rule_3582(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3582i64); + } + self.parse_child(662i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3582i64); + } + self.parse_child(661i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexTypeClause + fn parse_rule_3583(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 599i64 | 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3583i64); + } + self.parse_child(3584i64, &mut branch_matches, &mut has_children); + self.parse_child(3577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1120 + fn parse_rule_3584(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 599i64 | 621i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(621i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(599i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fulltextIndexOption + fn parse_rule_3585(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 264i64 | 645i64 | 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3585i64); + } + self.parse_child(3580i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3585i64); + } + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(401i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // spatialIndexOption + fn parse_rule_3586(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 264i64 | 661i64 | 662i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3586i64); + } + self.parse_child(3580i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dataTypeDefinition + fn parse_rule_3587(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 31i64 | 32i64 | 37i64 | 39i64 | 41i64 | 42i64 | 60i64 | 113i64 | 116i64 | 126i64 | 146i64 | 164i64 | 192i64 | 195i64 | 211i64 | 212i64 | 249i64 | 262i64 | + 279i64 | 290i64 | 291i64 | 293i64 | 330i64 | 331i64 | 332i64 | 351i64 | 352i64 | 353i64 | 358i64 | 361i64 | 378i64 | 379i64 | 411i64 | 412i64 | 437i64 | 501i64 | + 506i64 | 516i64 | 580i64 | 583i64 | 586i64 | 587i64 | 588i64 | 589i64 | 628i64 | 629i64 | 656i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3587i64); + } + self.parse_child(3592i64, &mut branch_matches, &mut has_children); + self.parse_child(-1i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1121 + fn parse_rule_3588(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3609i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1122 + fn parse_rule_3589(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3871i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1123 + fn parse_rule_3590(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1124 + fn parse_rule_3591(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3601i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dataType + fn parse_rule_3592(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 31i64 | 32i64 | 37i64 | 39i64 | 41i64 | 42i64 | 60i64 | 113i64 | 116i64 | 126i64 | 146i64 | 164i64 | 192i64 | 195i64 | 211i64 | 212i64 | 249i64 | 262i64 | + 279i64 | 290i64 | 291i64 | 293i64 | 330i64 | 331i64 | 332i64 | 351i64 | 352i64 | 353i64 | 358i64 | 361i64 | 378i64 | 379i64 | 411i64 | 412i64 | 437i64 | 501i64 | + 506i64 | 516i64 | 580i64 | 583i64 | 586i64 | 587i64 | 588i64 | 589i64 | 628i64 | 629i64 | 656i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3593i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(3588i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3595i64, &mut branch_matches, &mut has_children); + self.parse_child(3589i64, &mut branch_matches, &mut has_children); + self.parse_child(3588i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3596i64, &mut branch_matches, &mut has_children); + self.parse_child(3397i64, &mut branch_matches, &mut has_children); + self.parse_child(3588i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(37i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3597i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3598i64, &mut branch_matches, &mut has_children); + self.parse_child(3606i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3599i64, &mut branch_matches, &mut has_children); + self.parse_child(3606i64, &mut branch_matches, &mut has_children); + self.parse_child(3590i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3604i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(3590i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(628i64, &mut branch_matches, &mut has_children); + self.parse_child(3606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(656i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(3588i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(116i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(583i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(113i64, &mut branch_matches, &mut has_children); + self.parse_child(3242i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(587i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(39i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3600i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(293i64, &mut branch_matches, &mut has_children); + self.parse_child(628i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(293i64, &mut branch_matches, &mut has_children); + self.parse_child(3591i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(589i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(580i64, &mut branch_matches, &mut has_children); + self.parse_child(3394i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(332i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(291i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(164i64, &mut branch_matches, &mut has_children); + self.parse_child(3851i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(506i64, &mut branch_matches, &mut has_children); + self.parse_child(3851i64, &mut branch_matches, &mut has_children); + self.parse_child(3395i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3592i64); + } + self.parse_child(3603i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1125 + fn parse_rule_3593(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 31i64 | 249i64 | 331i64 | 516i64 | 588i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(249i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(588i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(516i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(331i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(31i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1126 + fn parse_rule_3594(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(416i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1127 + fn parse_rule_3595(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 146i64 | 437i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(437i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(146i64, &mut branch_matches, &mut has_children); + self.parse_child(3594i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1128 + fn parse_rule_3596(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 126i64 | 192i64 | 195i64 | 378i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(195i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(126i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(378i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1129 + fn parse_rule_3597(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 41i64 | 42i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(42i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(41i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1130 + fn parse_rule_3598(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 60i64 | 629i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(633i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1131 + fn parse_rule_3599(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 358i64 | 361i64 | 379i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(358i64, &mut branch_matches, &mut has_children); + self.parse_child(629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(379i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(361i64, &mut branch_matches, &mut has_children); + self.parse_child(629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(358i64, &mut branch_matches, &mut has_children); + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(633i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(361i64, &mut branch_matches, &mut has_children); + self.parse_child(633i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1132 + fn parse_rule_3600(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 290i64 | 330i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(330i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(290i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1133 + fn parse_rule_3601(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 60i64 | 629i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(60i64, &mut branch_matches, &mut has_children); + self.parse_child(633i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1134 + fn parse_rule_3602(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 262i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1135 + fn parse_rule_3603(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 211i64 | 212i64 | 279i64 | 351i64 | 352i64 | 353i64 | 411i64 | 412i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(212i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(211i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(411i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(352i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(279i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(351i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(353i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // nchar + fn parse_rule_3604(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 358i64 | 361i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3604i64); + } + self.parse_child(361i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3604i64); + } + self.parse_child(358i64, &mut branch_matches, &mut has_children); + self.parse_child(60i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // realType + fn parse_rule_3605(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 146i64 | 437i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3605i64); + } + self.parse_child(437i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3605i64); + } + self.parse_child(146i64, &mut branch_matches, &mut has_children); + self.parse_child(3594i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldLength + fn parse_rule_3606(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3606i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3607i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1136 + fn parse_rule_3607(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 783i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1137 + fn parse_rule_3608(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 512i64 | 612i64 | 657i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3610i64, &mut branch_matches, &mut has_children); + self.parse_child(3608i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3610i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldOptions + fn parse_rule_3609(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 512i64 | 612i64 | 657i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3609i64); + } + self.parse_child(3608i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1138 + fn parse_rule_3610(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 512i64 | 612i64 | 657i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(512i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(612i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(657i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1139 + fn parse_rule_3611(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // charsetWithOptBinary + fn parse_rule_3612(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 19i64 | 32i64 | 46i64 | 58i64 | 60i64 | 606i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3612i64); + } + self.parse_child(3614i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3612i64); + } + self.parse_child(3615i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3612i64); + } + self.parse_child(46i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3612i64); + } + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + self.parse_child(3590i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3612i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(3611i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1140 + fn parse_rule_3613(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ascii + fn parse_rule_3614(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 19i64 | 32i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3614i64); + } + self.parse_child(19i64, &mut branch_matches, &mut has_children); + self.parse_child(3590i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3614i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(19i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // unicode + fn parse_rule_3615(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64 | 606i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3615i64); + } + self.parse_child(606i64, &mut branch_matches, &mut has_children); + self.parse_child(3590i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3615i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + self.parse_child(606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // wsNumCodepoints + fn parse_rule_3616(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3616i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // typeDatetimePrecision + fn parse_rule_3617(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3617i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // charsetName + fn parse_rule_3618(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3618i64); + } + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3618i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3618i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1141 + fn parse_rule_3619(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // collationName + fn parse_rule_3620(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | + 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | + 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 128i64 | + 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | + 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | + 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | + 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | + 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | + 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | + 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | + 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | + 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3620i64); + } + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3620i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3620i64); + } + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1142 + fn parse_rule_3621(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1143 + fn parse_rule_3622(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 32i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(32i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1144 + fn parse_rule_3623(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3629i64, &mut branch_matches, &mut has_children); + self.parse_child(3623i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createTableOptions + fn parse_rule_3624(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 23i64 | 24i64 | 25i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 112i64 | 128i64 | 132i64 | 158i64 | 163i64 | 236i64 | 243i64 | 264i64 | + 323i64 | 344i64 | 399i64 | 406i64 | 486i64 | 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3624i64); + } + self.parse_child(3629i64, &mut branch_matches, &mut has_children); + self.parse_child(3623i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1145 + fn parse_rule_3625(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 23i64 | 24i64 | 25i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 112i64 | 128i64 | 132i64 | 158i64 | 163i64 | 236i64 | 243i64 | 264i64 | + 323i64 | 344i64 | 399i64 | 406i64 | 486i64 | 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 721i64 | 750i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2053i64, &mut branch_matches, &mut has_children); + self.parse_child(3629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1146 + fn parse_rule_3626(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 23i64 | 24i64 | 25i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 112i64 | 128i64 | 132i64 | 158i64 | 163i64 | 236i64 | 243i64 | 264i64 | + 323i64 | 344i64 | 399i64 | 406i64 | 486i64 | 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3629i64, &mut branch_matches, &mut has_children); + self.parse_child(3626i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3629i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createTableOptionsSpaceSeparated + fn parse_rule_3627(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 23i64 | 24i64 | 25i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 112i64 | 128i64 | 132i64 | 158i64 | 163i64 | 236i64 | 243i64 | 264i64 | + 323i64 | 344i64 | 399i64 | 406i64 | 486i64 | 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3627i64); + } + self.parse_child(3626i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1147 + fn parse_rule_3628(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3813i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createTableOption + fn parse_rule_3629(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 23i64 | 24i64 | 25i64 | 58i64 | 60i64 | 61i64 | 69i64 | 75i64 | 81i64 | 84i64 | 112i64 | 128i64 | 132i64 | 158i64 | 163i64 | 236i64 | 243i64 | 264i64 | + 323i64 | 344i64 | 399i64 | 406i64 | 486i64 | 543i64 | 544i64 | 545i64 | 546i64 | 553i64 | 572i64 | 575i64 | 608i64 | 721i64 | 848i64 | 849i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(163i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3801i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(721i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(3630i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(323i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(344i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(25i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(406i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(81i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(158i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(24i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(399i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3645i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(3634i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3645i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(3635i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(132i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(486i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(608i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3628i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(3649i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(3647i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(243i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3637i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(112i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(236i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(3639i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(553i64, &mut branch_matches, &mut has_children); + self.parse_child(3640i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(84i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(264i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(543i64, &mut branch_matches, &mut has_children); + self.parse_child(592i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(848i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(849i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3629i64); + } + self.parse_child(2277i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1148 + fn parse_rule_3630(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1149 + fn parse_rule_3631(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 721i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(721i64, &mut branch_matches, &mut has_children); + self.parse_child(2843i64, &mut branch_matches, &mut has_children); + self.parse_child(3630i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1150 + fn parse_rule_3632(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 81i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(81i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1151 + fn parse_rule_3633(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(158i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1152 + fn parse_rule_3634(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 544i64 | 545i64 | 546i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(544i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(545i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(546i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1153 + fn parse_rule_3635(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 61i64 | 575i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(61i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(575i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1154 + fn parse_rule_3636(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 78i64 | 80i64 | 128i64 | 152i64 | 192i64 | 442i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(80i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(442i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(78i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1155 + fn parse_rule_3637(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 191i64 | 268i64 | 373i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(268i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1156 + fn parse_rule_3638(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1157 + fn parse_rule_3639(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1158 + fn parse_rule_3640(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 142i64 | 334i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1159 + fn parse_rule_3641(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 543i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(543i64, &mut branch_matches, &mut has_children); + self.parse_child(592i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1160 + fn parse_rule_3642(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 848i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(848i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1161 + fn parse_rule_3643(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 849i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(849i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1162 + fn parse_rule_3644(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 23i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2277i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ternaryOption + fn parse_rule_3645(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 783i64 | 785i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3645i64); + } + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3645i64); + } + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1163 + fn parse_rule_3646(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // defaultCollation + fn parse_rule_3647(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 69i64 | 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3647i64); + } + self.parse_child(3646i64, &mut branch_matches, &mut has_children); + self.parse_child(69i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3620i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // defaultEncryption + fn parse_rule_3648(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 128i64 | 158i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3648i64); + } + self.parse_child(3646i64, &mut branch_matches, &mut has_children); + self.parse_child(158i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // defaultCharset + fn parse_rule_3649(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64 | 128i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3649i64); + } + self.parse_child(3646i64, &mut branch_matches, &mut has_children); + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1164 + fn parse_rule_3650(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1165 + fn parse_rule_3651(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3662i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1166 + fn parse_rule_3652(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3668i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionClause + fn parse_rule_3653(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3653i64); + } + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3658i64, &mut branch_matches, &mut has_children); + self.parse_child(3650i64, &mut branch_matches, &mut has_children); + self.parse_child(3651i64, &mut branch_matches, &mut has_children); + self.parse_child(3652i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1167 + fn parse_rule_3654(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 404i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1168 + fn parse_rule_3655(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(277i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1169 + fn parse_rule_3656(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3665i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1170 + fn parse_rule_3657(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionTypeDef + fn parse_rule_3658(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 220i64 | 265i64 | 277i64 | 280i64 | 432i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3658i64); + } + self.parse_child(3655i64, &mut branch_matches, &mut has_children); + self.parse_child(265i64, &mut branch_matches, &mut has_children); + self.parse_child(3656i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3657i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3658i64); + } + self.parse_child(3655i64, &mut branch_matches, &mut has_children); + self.parse_child(220i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3658i64); + } + self.parse_child(3659i64, &mut branch_matches, &mut has_children); + self.parse_child(3660i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1171 + fn parse_rule_3659(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 280i64 | 432i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(432i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(280i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1172 + fn parse_rule_3660(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 71i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(71i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3657i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1173 + fn parse_rule_3661(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(560i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // subPartitions + fn parse_rule_3662(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 561i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3662i64); + } + self.parse_child(561i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3655i64, &mut branch_matches, &mut has_children); + self.parse_child(3663i64, &mut branch_matches, &mut has_children); + self.parse_child(3661i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1174 + fn parse_rule_3663(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 220i64 | 265i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(220i64, &mut branch_matches, &mut has_children); + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(265i64, &mut branch_matches, &mut has_children); + self.parse_child(3656i64, &mut branch_matches, &mut has_children); + self.parse_child(3834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1175 + fn parse_rule_3664(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 560i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(560i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionKeyAlgorithm + fn parse_rule_3665(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3665i64); + } + self.parse_child(9i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1176 + fn parse_rule_3666(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 9i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(9i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1177 + fn parse_rule_3667(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3673i64, &mut branch_matches, &mut has_children); + self.parse_child(3667i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3673i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionDefinitions + fn parse_rule_3668(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3668i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3673i64, &mut branch_matches, &mut has_children); + self.parse_child(3667i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1178 + fn parse_rule_3669(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3673i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1179 + fn parse_rule_3670(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3675i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1180 + fn parse_rule_3671(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3682i64, &mut branch_matches, &mut has_children); + self.parse_child(3671i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1181 + fn parse_rule_3672(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3685i64, &mut branch_matches, &mut has_children); + self.parse_child(3676i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionDefinition + fn parse_rule_3673(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3673i64); + } + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3670i64, &mut branch_matches, &mut has_children); + self.parse_child(3671i64, &mut branch_matches, &mut has_children); + self.parse_child(3672i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1182 + fn parse_rule_3674(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 329i64 | 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3687i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(329i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1183 + fn parse_rule_3675(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 626i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(626i64, &mut branch_matches, &mut has_children); + self.parse_child(273i64, &mut branch_matches, &mut has_children); + self.parse_child(581i64, &mut branch_matches, &mut has_children); + self.parse_child(3674i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(626i64, &mut branch_matches, &mut has_children); + self.parse_child(251i64, &mut branch_matches, &mut has_children); + self.parse_child(3680i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1184 + fn parse_rule_3676(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3685i64, &mut branch_matches, &mut has_children); + self.parse_child(3676i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3685i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1185 + fn parse_rule_3677(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3685i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1186 + fn parse_rule_3678(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3685i64, &mut branch_matches, &mut has_children); + self.parse_child(3676i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1187 + fn parse_rule_3679(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3687i64, &mut branch_matches, &mut has_children); + self.parse_child(3679i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3687i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionValuesIn + fn parse_rule_3680(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3680i64); + } + self.parse_child(3687i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3680i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3687i64, &mut branch_matches, &mut has_children); + self.parse_child(3679i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1188 + fn parse_rule_3681(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3687i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionOption + fn parse_rule_3682(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 75i64 | 112i64 | 163i64 | 236i64 | 323i64 | 344i64 | 368i64 | 553i64 | 572i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3682i64); + } + self.parse_child(572i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3682i64); + } + self.parse_child(2281i64, &mut branch_matches, &mut has_children); + self.parse_child(163i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3801i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3682i64); + } + self.parse_child(368i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3682i64); + } + self.parse_child(3683i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3682i64); + } + self.parse_child(3684i64, &mut branch_matches, &mut has_children); + self.parse_child(139i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3682i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + self.parse_child(2127i64, &mut branch_matches, &mut has_children); + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1189 + fn parse_rule_3683(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 323i64 | 344i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(344i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1190 + fn parse_rule_3684(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 112i64 | 236i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(236i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // subpartitionDefinition + fn parse_rule_3685(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 561i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3685i64); + } + self.parse_child(561i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + self.parse_child(3671i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1191 + fn parse_rule_3686(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3689i64, &mut branch_matches, &mut has_children); + self.parse_child(3686i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionValueItemListParen + fn parse_rule_3687(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3687i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3689i64, &mut branch_matches, &mut has_children); + self.parse_child(3686i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1192 + fn parse_rule_3688(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // partitionValueItem + fn parse_rule_3689(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 329i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | + 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3689i64); + } + self.parse_child(3216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3689i64); + } + self.parse_child(329i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // definerClause + fn parse_rule_3690(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 130i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3690i64); + } + self.parse_child(130i64, &mut branch_matches, &mut has_children); + self.parse_child(763i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ifExists + fn parse_rule_3691(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3691i64); + } + self.parse_child(231i64, &mut branch_matches, &mut has_children); + self.parse_child(174i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ifNotExists + fn parse_rule_3692(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 231i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3692i64); + } + self.parse_child(231i64, &mut branch_matches, &mut has_children); + self.parse_child(3407i64, &mut branch_matches, &mut has_children); + self.parse_child(174i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1193 + fn parse_rule_3693(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3695i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // procedureParameter + fn parse_rule_3694(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 240i64 | 243i64 | 244i64 | 245i64 | 250i64 | 251i64 | 255i64 | 256i64 | 258i64 | 259i64 | + 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | + 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | + 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | + 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | + 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 397i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | + 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | + 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | + 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | + 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | + 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | + 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | + 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | + 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3694i64); + } + self.parse_child(3693i64, &mut branch_matches, &mut has_children); + self.parse_child(3696i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1194 + fn parse_rule_3695(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 240i64 | 251i64 | 397i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(251i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(397i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(240i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // functionParameter + fn parse_rule_3696(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3696i64); + } + self.parse_child(3818i64, &mut branch_matches, &mut has_children); + self.parse_child(3698i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // collate + fn parse_rule_3697(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 69i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3697i64); + } + self.parse_child(69i64, &mut branch_matches, &mut has_children); + self.parse_child(3620i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // typeWithOptCollate + fn parse_rule_3698(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 31i64 | 32i64 | 37i64 | 39i64 | 41i64 | 42i64 | 60i64 | 113i64 | 116i64 | 126i64 | 146i64 | 164i64 | 192i64 | 195i64 | 211i64 | 212i64 | 249i64 | 262i64 | + 279i64 | 290i64 | 291i64 | 293i64 | 330i64 | 331i64 | 332i64 | 351i64 | 352i64 | 353i64 | 358i64 | 361i64 | 378i64 | 379i64 | 411i64 | 412i64 | 437i64 | 501i64 | + 506i64 | 516i64 | 580i64 | 583i64 | 586i64 | 587i64 | 588i64 | 589i64 | 628i64 | 629i64 | 656i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3698i64); + } + self.parse_child(3592i64, &mut branch_matches, &mut has_children); + self.parse_child(2096i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // schemaIdentifierPair + fn parse_rule_3699(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3699i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1195 + fn parse_rule_3700(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3790i64, &mut branch_matches, &mut has_children); + self.parse_child(3700i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3790i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewRefList + fn parse_rule_3701(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3701i64); + } + self.parse_child(3790i64, &mut branch_matches, &mut has_children); + self.parse_child(3700i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1196 + fn parse_rule_3702(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3790i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1197 + fn parse_rule_3703(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3706i64, &mut branch_matches, &mut has_children); + self.parse_child(3703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3706i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // updateList + fn parse_rule_3704(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3704i64); + } + self.parse_child(3706i64, &mut branch_matches, &mut has_children); + self.parse_child(3703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1198 + fn parse_rule_3705(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3706i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // updateElement + fn parse_rule_3706(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3706i64); + } + self.parse_child(3773i64, &mut branch_matches, &mut has_children); + self.parse_child(3877i64, &mut branch_matches, &mut has_children); + self.parse_child(3707i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1199 + fn parse_rule_3707(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 32i64 | 33i64 | 35i64 | 36i64 | 37i64 | 38i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 51i64 | 52i64 | 53i64 | 54i64 | + 56i64 | 57i64 | 58i64 | 60i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | + 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 94i64 | 95i64 | 96i64 | 99i64 | 100i64 | + 101i64 | 105i64 | 107i64 | 108i64 | 109i64 | 111i64 | 112i64 | 113i64 | 114i64 | 115i64 | 116i64 | 122i64 | 123i64 | 128i64 | 129i64 | 130i64 | 132i64 | 136i64 | + 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | + 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 174i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 182i64 | 183i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 218i64 | 219i64 | + 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 231i64 | 233i64 | 234i64 | 235i64 | 238i64 | 242i64 | 243i64 | 244i64 | 245i64 | 247i64 | 250i64 | 255i64 | + 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 272i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 320i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 326i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 345i64 | 346i64 | 348i64 | 349i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 371i64 | 372i64 | 373i64 | 374i64 | 376i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | + 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 414i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 457i64 | 458i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | + 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 478i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | + 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 548i64 | 551i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 563i64 | 564i64 | 565i64 | 566i64 | 567i64 | 568i64 | 569i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | + 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 595i64 | 596i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | + 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 622i64 | 623i64 | 624i64 | 625i64 | 626i64 | 627i64 | 631i64 | 632i64 | 635i64 | + 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | + 664i64 | 666i64 | 667i64 | 669i64 | 670i64 | 671i64 | 672i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 678i64 | 679i64 | 680i64 | 681i64 | 682i64 | 684i64 | + 685i64 | 686i64 | 687i64 | 688i64 | 689i64 | 690i64 | 692i64 | 693i64 | 694i64 | 695i64 | 696i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 745i64 | 746i64 | 751i64 | 752i64 | 753i64 | 754i64 | 758i64 | 771i64 | 773i64 | 778i64 | 781i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | + 789i64 | 790i64 | 791i64 | 792i64 | 793i64 | 794i64 | 800i64 | 801i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | + 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | + 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(128i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // charsetClause + fn parse_rule_3708(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 58i64 | 60i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3708i64); + } + self.parse_child(3406i64, &mut branch_matches, &mut has_children); + self.parse_child(3618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1200 + fn parse_rule_3709(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 157i64 | 167i64 | 392i64 | 579i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3712i64, &mut branch_matches, &mut has_children); + self.parse_child(3709i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3712i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldsClause + fn parse_rule_3710(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 71i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3710i64); + } + self.parse_child(71i64, &mut branch_matches, &mut has_children); + self.parse_child(3709i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1201 + fn parse_rule_3711(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(392i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldTerm + fn parse_rule_3712(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 157i64 | 167i64 | 392i64 | 579i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3712i64); + } + self.parse_child(579i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3712i64); + } + self.parse_child(3711i64, &mut branch_matches, &mut has_children); + self.parse_child(157i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3712i64); + } + self.parse_child(167i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1202 + fn parse_rule_3713(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 541i64 | 579i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3715i64, &mut branch_matches, &mut has_children); + self.parse_child(3713i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3715i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // linesClause + fn parse_rule_3714(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 278i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3714i64); + } + self.parse_child(278i64, &mut branch_matches, &mut has_children); + self.parse_child(3713i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lineTerm + fn parse_rule_3715(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 541i64 | 579i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3715i64); + } + self.parse_child(3716i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1203 + fn parse_rule_3716(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 541i64 | 579i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(579i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(541i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1204 + fn parse_rule_3717(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(3717i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // userList + fn parse_rule_3718(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3718i64); + } + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(3717i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1205 + fn parse_rule_3719(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1206 + fn parse_rule_3720(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3727i64, &mut branch_matches, &mut has_children); + self.parse_child(3720i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3727i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createUserList + fn parse_rule_3721(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3721i64); + } + self.parse_child(3727i64, &mut branch_matches, &mut has_children); + self.parse_child(3720i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1207 + fn parse_rule_3722(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3727i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1208 + fn parse_rule_3723(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3739i64, &mut branch_matches, &mut has_children); + self.parse_child(3723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3739i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterUserList + fn parse_rule_3724(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3724i64); + } + self.parse_child(3739i64, &mut branch_matches, &mut has_children); + self.parse_child(3723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1209 + fn parse_rule_3725(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3739i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1210 + fn parse_rule_3726(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(3737i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // createUserEntry + fn parse_rule_3727(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3727i64); + } + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + self.parse_child(3726i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1211 + fn parse_rule_3728(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 406i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1212 + fn parse_rule_3729(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1213 + fn parse_rule_3730(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 406i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1214 + fn parse_rule_3731(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 45i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1215 + fn parse_rule_3732(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3733i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1216 + fn parse_rule_3733(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64 | 45i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3856i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1217 + fn parse_rule_3734(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1218 + fn parse_rule_3735(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1219 + fn parse_rule_3736(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 45i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3734i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(734i64, &mut branch_matches, &mut has_children); + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1220 + fn parse_rule_3737(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 45i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3729i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + self.parse_child(3732i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3734i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(734i64, &mut branch_matches, &mut has_children); + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1221 + fn parse_rule_3738(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 230i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(3737i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // alterUserEntry + fn parse_rule_3739(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3739i64); + } + self.parse_child(3740i64, &mut branch_matches, &mut has_children); + self.parse_child(3750i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1222 + fn parse_rule_3740(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2862i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3758i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1223 + fn parse_rule_3741(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1224 + fn parse_rule_3742(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1225 + fn parse_rule_3743(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 734i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(734i64, &mut branch_matches, &mut has_children); + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1226 + fn parse_rule_3744(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 734i64 | 782i64 | 784i64 | 786i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(734i64, &mut branch_matches, &mut has_children); + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1227 + fn parse_rule_3745(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3856i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1228 + fn parse_rule_3746(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 17i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(17i64, &mut branch_matches, &mut has_children); + self.parse_child(3856i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1229 + fn parse_rule_3747(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1230 + fn parse_rule_3748(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 45i64 | 645i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3741i64, &mut branch_matches, &mut has_children); + self.parse_child(45i64, &mut branch_matches, &mut has_children); + self.parse_child(3744i64, &mut branch_matches, &mut has_children); + self.parse_child(3026i64, &mut branch_matches, &mut has_children); + self.parse_child(3027i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(645i64, &mut branch_matches, &mut has_children); + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + self.parse_child(3745i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1231 + fn parse_rule_3749(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 141i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3752i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1232 + fn parse_rule_3750(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(230i64, &mut branch_matches, &mut has_children); + self.parse_child(3747i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3752i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // retainCurrentPassword + fn parse_rule_3751(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 727i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3751i64); + } + self.parse_child(727i64, &mut branch_matches, &mut has_children); + self.parse_child(101i64, &mut branch_matches, &mut has_children); + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // discardOldPassword + fn parse_rule_3752(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 141i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3752i64); + } + self.parse_child(141i64, &mut branch_matches, &mut has_children); + self.parse_child(728i64, &mut branch_matches, &mut has_children); + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // replacePassword + fn parse_rule_3753(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 458i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3753i64); + } + self.parse_child(458i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1233 + fn parse_rule_3754(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3757i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // userIdentifierOrText + fn parse_rule_3755(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3755i64); + } + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + self.parse_child(3754i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1234 + fn parse_rule_3756(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1235 + fn parse_rule_3757(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 746i64 | 792i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(746i64, &mut branch_matches, &mut has_children); + self.parse_child(3756i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(792i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // user + fn parse_rule_3758(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 105i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | + 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | + 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | + 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | + 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | + 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | + 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | + 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | + 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | + 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | + 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | + 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | + 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | + 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | + 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | + 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | + 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | + 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3758i64); + } + self.parse_child(3755i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3758i64); + } + self.parse_child(105i64, &mut branch_matches, &mut has_children); + self.parse_child(3323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // likeClause + fn parse_rule_3759(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 275i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3759i64); + } + self.parse_child(275i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // likeOrWhere + fn parse_rule_3760(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 275i64 | 643i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3760i64); + } + self.parse_child(3759i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3760i64); + } + self.parse_child(2585i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // onlineOption + fn parse_rule_3761(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 380i64 | 385i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3761i64); + } + self.parse_child(385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3761i64); + } + self.parse_child(380i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // noWriteToBinLog + fn parse_rule_3762(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 284i64 | 375i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3762i64); + } + self.parse_child(284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3762i64); + } + self.parse_child(375i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // usePartition + fn parse_rule_3763(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3763i64); + } + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(3834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1236 + fn parse_rule_3764(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 405i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(405i64, &mut branch_matches, &mut has_children); + self.parse_child(3834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // fieldIdentifier + fn parse_rule_3765(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3765i64); + } + self.parse_child(3766i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3765i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1237 + fn parse_rule_3766(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1238 + fn parse_rule_3767(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3766i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1239 + fn parse_rule_3768(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnInternalRef + fn parse_rule_3769(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3769i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1240 + fn parse_rule_3770(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3769i64, &mut branch_matches, &mut has_children); + self.parse_child(3770i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3769i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnInternalRefList + fn parse_rule_3771(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3771i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3769i64, &mut branch_matches, &mut has_children); + self.parse_child(3770i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1241 + fn parse_rule_3772(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3769i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // columnRef + fn parse_rule_3773(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3773i64); + } + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // insertIdentifier + fn parse_rule_3774(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3774i64); + } + self.parse_child(3773i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3774i64); + } + self.parse_child(3778i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexName + fn parse_rule_3775(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3775i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // indexRef + fn parse_rule_3776(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3776i64); + } + self.parse_child(3765i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1242 + fn parse_rule_3777(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableWild + fn parse_rule_3778(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3778i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(3777i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1243 + fn parse_rule_3779(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // schemaName + fn parse_rule_3780(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3780i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // schemaRef + fn parse_rule_3781(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3781i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // procedureName + fn parse_rule_3782(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3782i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // procedureRef + fn parse_rule_3783(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3783i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // functionName + fn parse_rule_3784(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3784i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // functionRef + fn parse_rule_3785(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3785i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // triggerName + fn parse_rule_3786(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3786i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // triggerRef + fn parse_rule_3787(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3787i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewName + fn parse_rule_3788(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3788i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3788i64); + } + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1244 + fn parse_rule_3789(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // viewRef + fn parse_rule_3790(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3790i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3790i64); + } + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1245 + fn parse_rule_3791(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tablespaceName + fn parse_rule_3792(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3792i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tablespaceRef + fn parse_rule_3793(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3793i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // logfileGroupName + fn parse_rule_3794(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3794i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // logfileGroupRef + fn parse_rule_3795(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3795i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // eventName + fn parse_rule_3796(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3796i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // eventRef + fn parse_rule_3797(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3797i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // udfName + fn parse_rule_3798(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3798i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // serverName + fn parse_rule_3799(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3799i64); + } + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // serverRef + fn parse_rule_3800(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3800i64); + } + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // engineRef + fn parse_rule_3801(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3801i64); + } + self.parse_child(3872i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableName + fn parse_rule_3802(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3802i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3802i64); + } + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1246 + fn parse_rule_3803(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // filterTableRef + fn parse_rule_3804(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3804i64); + } + self.parse_child(3781i64, &mut branch_matches, &mut has_children); + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1247 + fn parse_rule_3805(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3809i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableRefWithWildcard + fn parse_rule_3806(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3806i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3805i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1248 + fn parse_rule_3807(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1249 + fn parse_rule_3808(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1250 + fn parse_rule_3809(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(775i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + self.parse_child(3807i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableRef + fn parse_rule_3810(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3810i64); + } + self.parse_child(3835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3810i64); + } + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1251 + fn parse_rule_3811(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1252 + fn parse_rule_3812(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3812i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableRefList + fn parse_rule_3813(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3813i64); + } + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + self.parse_child(3812i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1253 + fn parse_rule_3814(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3810i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1254 + fn parse_rule_3815(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3806i64, &mut branch_matches, &mut has_children); + self.parse_child(3815i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3806i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // tableAliasRefList + fn parse_rule_3816(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3816i64); + } + self.parse_child(3806i64, &mut branch_matches, &mut has_children); + self.parse_child(3815i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1255 + fn parse_rule_3817(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3806i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // parameterName + fn parse_rule_3818(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3818i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // labelIdentifier + fn parse_rule_3819(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | + 73i64 | 74i64 | 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | + 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | + 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3819i64); + } + self.parse_child(3827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3819i64); + } + self.parse_child(3889i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // labelRef + fn parse_rule_3820(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | + 73i64 | 74i64 | 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | + 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | + 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3820i64); + } + self.parse_child(3819i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleIdentifier + fn parse_rule_3821(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | + 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | + 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3821i64); + } + self.parse_child(3827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3821i64); + } + self.parse_child(3898i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleRef + fn parse_rule_3822(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | + 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | + 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3822i64); + } + self.parse_child(3821i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // pluginRef + fn parse_rule_3823(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3823i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // componentRef + fn parse_rule_3824(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3824i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // resourceGroupRef + fn parse_rule_3825(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3825i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // windowName + fn parse_rule_3826(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3826i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // pureIdentifier + fn parse_rule_3827(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 781i64 | 784i64 | 793i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3827i64); + } + self.parse_child(3828i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3827i64); + } + self.parse_child(784i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1256 + fn parse_rule_3828(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 781i64 | 793i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(793i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(781i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1257 + fn parse_rule_3829(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(784i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifier + fn parse_rule_3830(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3830i64); + } + self.parse_child(3827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3830i64); + } + self.parse_child(3881i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1258 + fn parse_rule_3831(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3831i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierList + fn parse_rule_3832(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3832i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3831i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1259 + fn parse_rule_3833(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierListWithParentheses + fn parse_rule_3834(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3834i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3832i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // qualifiedIdentifier + fn parse_rule_3835(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | + 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | + 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3835i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1260 + fn parse_rule_3836(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // simpleIdentifier + fn parse_rule_3837(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 751i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3837i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + self.parse_child(3836i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3837i64); + } + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1261 + fn parse_rule_3838(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + self.parse_child(3385i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1262 + fn parse_rule_3839(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + self.parse_child(3840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // dotIdentifier + fn parse_rule_3840(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 751i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3840i64); + } + self.parse_child(751i64, &mut branch_matches, &mut has_children); + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ulong_number + fn parse_rule_3841(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 783i64 | 785i64 | 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3841i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3841i64); + } + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3841i64); + } + self.parse_child(788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3841i64); + } + self.parse_child(791i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3841i64); + } + self.parse_child(783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3841i64); + } + self.parse_child(785i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // real_ulong_number + fn parse_rule_3842(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3842i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3842i64); + } + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3842i64); + } + self.parse_child(788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3842i64); + } + self.parse_child(791i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // ulonglong_number + fn parse_rule_3843(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 783i64 | 785i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3843i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3843i64); + } + self.parse_child(788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3843i64); + } + self.parse_child(791i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3843i64); + } + self.parse_child(783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3843i64); + } + self.parse_child(785i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // real_ulonglong_number + fn parse_rule_3844(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3844i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3844i64); + } + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3844i64); + } + self.parse_child(791i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3844i64); + } + self.parse_child(788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1263 + fn parse_rule_3845(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1264 + fn parse_rule_3846(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(794i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // literal + fn parse_rule_3847(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 116i64 | 183i64 | 376i64 | 583i64 | 586i64 | 596i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | 791i64 | 794i64 | 801i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3847i64); + } + self.parse_child(3859i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3847i64); + } + self.parse_child(3865i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3847i64); + } + self.parse_child(3868i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3847i64); + } + self.parse_child(3867i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3847i64); + } + self.parse_child(3866i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3847i64); + } + self.parse_child(3846i64, &mut branch_matches, &mut has_children); + self.parse_child(3848i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1265 + fn parse_rule_3848(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 782i64 | 786i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(782i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // signedLiteral + fn parse_rule_3849(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 116i64 | 183i64 | 376i64 | 583i64 | 586i64 | 596i64 | 773i64 | 778i64 | 782i64 | 783i64 | 784i64 | 785i64 | 786i64 | 787i64 | 788i64 | 789i64 | 790i64 | 791i64 | + 794i64 | 801i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3849i64); + } + self.parse_child(3847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3849i64); + } + self.parse_child(778i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3849i64); + } + self.parse_child(773i64, &mut branch_matches, &mut has_children); + self.parse_child(3841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1266 + fn parse_rule_3850(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(3850i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // stringList + fn parse_rule_3851(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3851i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + self.parse_child(3850i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1267 + fn parse_rule_3852(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3855i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textStringLiteral + fn parse_rule_3853(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3853i64); + } + self.parse_child(790i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3853i64); + } + self.parse_child(784i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1268 + fn parse_rule_3854(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(784i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textString + fn parse_rule_3855(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 782i64 | 784i64 | 786i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3855i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3855i64); + } + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3855i64); + } + self.parse_child(782i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textStringHash + fn parse_rule_3856(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 786i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3856i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3856i64); + } + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1269 + fn parse_rule_3857(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 786i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(786i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1270 + fn parse_rule_3858(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(3858i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textLiteral + fn parse_rule_3859(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 789i64 | 790i64 | 794i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3859i64); + } + self.parse_child(3860i64, &mut branch_matches, &mut has_children); + self.parse_child(3858i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1271 + fn parse_rule_3860(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 789i64 | 790i64 | 794i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3846i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(789i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textStringNoLinebreak + fn parse_rule_3861(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3861i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1272 + fn parse_rule_3862(&mut self, skip_current_node: bool) -> CompiledMatch { + // Nullable rules may still match without consuming input. + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(3862i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textStringLiteralList + fn parse_rule_3863(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 784i64 | 790i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3863i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + self.parse_child(3862i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1273 + fn parse_rule_3864(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 750i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // numLiteral + fn parse_rule_3865(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 783i64 | 785i64 | 787i64 | 788i64 | 791i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3865i64); + } + self.parse_child(787i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3865i64); + } + self.parse_child(788i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3865i64); + } + self.parse_child(791i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3865i64); + } + self.parse_child(783i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3865i64); + } + self.parse_child(785i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // boolLiteral + fn parse_rule_3866(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 183i64 | 596i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3866i64); + } + self.parse_child(596i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3866i64); + } + self.parse_child(183i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // nullLiteral + fn parse_rule_3867(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 376i64 | 801i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3867i64); + } + self.parse_child(376i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3867i64); + } + self.parse_child(801i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // temporalLiteral + fn parse_rule_3868(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 116i64 | 583i64 | 586i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3868i64); + } + self.parse_child(116i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3868i64); + } + self.parse_child(586i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3868i64); + } + self.parse_child(583i64, &mut branch_matches, &mut has_children); + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // floatOptions + fn parse_rule_3869(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3869i64); + } + self.parse_child(3606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3869i64); + } + self.parse_child(3871i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // standardFloatOptions + fn parse_rule_3870(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3870i64); + } + self.parse_child(3606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // precision + fn parse_rule_3871(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3871i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(750i64, &mut branch_matches, &mut has_children); + self.parse_child(787i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // textOrIdentifier + fn parse_rule_3872(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3872i64); + } + self.parse_child(3830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3872i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lValueIdentifier + fn parse_rule_3873(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 19i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 29i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | + 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | + 89i64 | 90i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | + 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | + 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | + 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | + 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | + 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | + 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | + 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | + 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | + 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | + 483i64 | 485i64 | 486i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | + 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | + 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | + 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | + 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 781i64 | 784i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | + 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | + 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3873i64); + } + self.parse_child(3827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3873i64); + } + self.parse_child(3902i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleIdentifierOrText + fn parse_rule_3874(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 781i64 | 784i64 | 790i64 | 793i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | + 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | + 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3874i64); + } + self.parse_child(3821i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3874i64); + } + self.parse_child(3853i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // sizeNumber + fn parse_rule_3875(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 781i64 | 784i64 | 786i64 | 787i64 | 788i64 | 791i64 | 793i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3875i64); + } + self.parse_child(3844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3875i64); + } + self.parse_child(3827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // parentheses + fn parse_rule_3876(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 753i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3876i64); + } + self.parse_child(753i64, &mut branch_matches, &mut has_children); + self.parse_child(748i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // equal + fn parse_rule_3877(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 756i64 | 763i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3877i64); + } + self.parse_child(763i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3877i64); + } + self.parse_child(756i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // optionType + fn parse_rule_3878(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 214i64 | 284i64 | 502i64 | 658i64 | 673i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3878i64); + } + self.parse_child(658i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3878i64); + } + self.parse_child(673i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3878i64); + } + self.parse_child(214i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3878i64); + } + self.parse_child(284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3878i64); + } + self.parse_child(502i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // varIdentType + fn parse_rule_3879(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 214i64 | 284i64 | 502i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3879i64); + } + self.parse_child(214i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3879i64); + } + self.parse_child(284i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3879i64); + } + self.parse_child(502i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // setVarIdentType + fn parse_rule_3880(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 214i64 | 284i64 | 502i64 | 658i64 | 673i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3880i64); + } + self.parse_child(658i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3880i64); + } + self.parse_child(673i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3880i64); + } + self.parse_child(214i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3880i64); + } + self.parse_child(284i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3880i64); + } + self.parse_child(502i64, &mut branch_matches, &mut has_children); + self.parse_child(751i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierKeyword + fn parse_rule_3881(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | + 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | + 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3881i64); + } + self.parse_child(3884i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3881i64); + } + self.parse_child(3886i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1274 + fn parse_rule_3882(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 510i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1275 + fn parse_rule_3883(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 714i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(714i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1276 + fn parse_rule_3884(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | + 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | + 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3889i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3904i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(173i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(714i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1277 + fn parse_rule_3885(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | + 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | + 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | + 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | + 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | + 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | + 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | + 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | + 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | + 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | + 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | + 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | + 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | + 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | + 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | + 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3884i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1278 + fn parse_rule_3886(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 19i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 29i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | + 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | + 89i64 | 90i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | + 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | + 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | + 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | + 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | + 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | + 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | + 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | + 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | + 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | + 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | + 454i64 | 455i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | + 481i64 | 482i64 | 483i64 | 485i64 | 486i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 510i64 | 512i64 | + 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | + 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | + 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | + 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | + 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | + 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | + 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | + 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3894i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3887i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3888i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3893i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3903i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierKeywordsAmbiguous1RolesAndLabels + fn parse_rule_3887(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 173i64 | 510i64 | 714i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3887i64); + } + self.parse_child(173i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3887i64); + } + self.parse_child(714i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3887i64); + } + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierKeywordsAmbiguous2Labels + fn parse_rule_3888(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 19i64 | 29i64 | 46i64 | 47i64 | 58i64 | 61i64 | 75i64 | 77i64 | 90i64 | 123i64 | 147i64 | 159i64 | 196i64 | 197i64 | 219i64 | 222i64 | 234i64 | 245i64 | + 267i64 | 373i64 | 415i64 | 417i64 | 455i64 | 468i64 | 480i64 | 489i64 | 512i64 | 514i64 | 543i64 | 552i64 | 597i64 | 606i64 | 607i64 | 651i64 | 677i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(19i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(29i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(46i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(47i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(58i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(61i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(677i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(75i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(77i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(90i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(147i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(196i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(197i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(219i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(222i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(234i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(245i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(267i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(373i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(415i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(417i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(455i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(468i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(480i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(489i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(512i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(552i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(597i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(607i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 34 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3888i64); + } + self.parse_child(651i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // labelKeyword + fn parse_rule_3889(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | + 73i64 | 74i64 | 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | + 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | + 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | + 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | + 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | + 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | + 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | + 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | + 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | + 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | + 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | + 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | + 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | + 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | + 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 715i64 | + 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | + 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | + 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | + 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3889i64); + } + self.parse_child(3890i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3889i64); + } + self.parse_child(3892i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1279 + fn parse_rule_3890(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 33i64 | 37i64 | 40i64 | 41i64 | + 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 78i64 | + 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | + 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 202i64 | 204i64 | 206i64 | 208i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 220i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | + 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | + 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | + 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | + 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 399i64 | 400i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | + 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 472i64 | 473i64 | 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 500i64 | + 501i64 | 502i64 | 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 650i64 | 652i64 | 653i64 | + 656i64 | 660i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 716i64 | 717i64 | 719i64 | 724i64 | 725i64 | 727i64 | 728i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3908i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(170i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(188i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(427i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(451i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(459i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(709i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1280 + fn parse_rule_3891(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 33i64 | 37i64 | 40i64 | 41i64 | + 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 78i64 | + 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | + 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | + 190i64 | 191i64 | 192i64 | 202i64 | 204i64 | 206i64 | 208i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 220i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | + 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | + 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | + 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | + 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | + 366i64 | 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 399i64 | 400i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | + 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | + 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | + 465i64 | 466i64 | 472i64 | 473i64 | 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 500i64 | + 501i64 | 502i64 | 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | + 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | + 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | + 610i64 | 613i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 650i64 | 652i64 | 653i64 | + 656i64 | 660i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 716i64 | 717i64 | 719i64 | 724i64 | 725i64 | 727i64 | 728i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3890i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1281 + fn parse_rule_3892(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | 37i64 | 40i64 | + 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | + 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | + 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | + 191i64 | 192i64 | 201i64 | 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | + 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | + 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | + 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 369i64 | 374i64 | 377i64 | 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | + 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | 427i64 | 429i64 | 430i64 | + 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 456i64 | 459i64 | 460i64 | 461i64 | + 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 485i64 | 486i64 | 488i64 | 490i64 | 492i64 | + 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 513i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | + 535i64 | 538i64 | 540i64 | 542i64 | 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 601i64 | + 602i64 | 603i64 | 604i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | + 647i64 | 648i64 | 650i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | + 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | + 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | + 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | + 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | + 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3894i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3893i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3903i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierKeywordsAmbiguous3Roles + fn parse_rule_3893(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 170i64 | 188i64 | 369i64 | 423i64 | 427i64 | 451i64 | 459i64 | 565i64 | 709i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(170i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(188i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(369i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(423i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(427i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(451i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(459i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(709i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3893i64); + } + self.parse_child(565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierKeywordsUnambiguous + fn parse_rule_3894(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | 37i64 | 40i64 | + 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | + 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | + 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | + 201i64 | 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 216i64 | 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 235i64 | 238i64 | 243i64 | + 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | + 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 374i64 | 377i64 | + 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 452i64 | 454i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | 474i64 | + 476i64 | 481i64 | 482i64 | 483i64 | 485i64 | 486i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 503i64 | 508i64 | 513i64 | 515i64 | 517i64 | + 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | + 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | + 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | + 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | + 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | + 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3894i64); + } + self.parse_child(3895i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3894i64); + } + self.parse_child(3896i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1282 + fn parse_rule_3895(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 33i64 | 37i64 | 40i64 | + 41i64 | 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | + 76i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | + 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | + 201i64 | 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 216i64 | 220i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 235i64 | 238i64 | 243i64 | + 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 286i64 | 288i64 | 289i64 | 296i64 | + 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | + 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | + 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 374i64 | 377i64 | + 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 413i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 452i64 | 454i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 470i64 | 472i64 | 473i64 | 474i64 | + 476i64 | 481i64 | 482i64 | 483i64 | 485i64 | 486i64 | 488i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 503i64 | 508i64 | 513i64 | 515i64 | 517i64 | + 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | + 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | + 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | + 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | + 729i64 | 730i64 | 732i64 | 735i64 | 736i64 | 737i64 | 738i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | + 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | + 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(5i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(660i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(6i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(7i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(8i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(9i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(12i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(16i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(21i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(812i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(23i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(24i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(25i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(26i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(27i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(33i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(37i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(40i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(41i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(42i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(44i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(675i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(50i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(53i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(54i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(56i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(57i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(63i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(64i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(65i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(66i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 34 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(67i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 35 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(68i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 36 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(70i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 37 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(71i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 38 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(74i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 39 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(73i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 40 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(76i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 41 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(78i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 42 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(79i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 43 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(664i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 44 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(80i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 45 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(81i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 46 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(82i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 47 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(84i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 48 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(85i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 49 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(87i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 50 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(88i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 51 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(89i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 52 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(91i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 53 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(96i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 54 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(101i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 55 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(107i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 56 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(111i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 57 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 58 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(113i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 59 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(116i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 60 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(122i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 61 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(129i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 62 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(130i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 63 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(715i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 64 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(132i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 65 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(716i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 66 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(138i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 67 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(139i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 68 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(140i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 69 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(141i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 70 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 71 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(150i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 72 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(151i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 73 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 74 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 75 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(158i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 76 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(160i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 77 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(730i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 78 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(162i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 79 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(163i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 80 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(848i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 81 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(164i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 82 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(166i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 83 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 84 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 85 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(169i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 86 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(171i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 87 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(172i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 88 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(680i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 89 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(176i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 90 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(177i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 91 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(179i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 92 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 93 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(181i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 94 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(184i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 95 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(185i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 96 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(189i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 97 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(190i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 98 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 99 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 100 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 101 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 102 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(202i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 103 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(204i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 104 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(208i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 105 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(211i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 106 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(212i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 107 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(213i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 108 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(713i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 109 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(840i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 110 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 111 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 112 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(841i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 113 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(220i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 114 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(674i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 115 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(705i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 116 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 117 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(224i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 118 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(229i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 119 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(230i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 120 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(233i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 121 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(725i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 122 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 123 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(238i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 124 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(844i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 125 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(243i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 126 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 127 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(661i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 128 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(250i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 129 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(255i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 130 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(256i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 131 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(258i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 132 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(259i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 133 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 134 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(264i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 135 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(847i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 136 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(268i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 137 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 138 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(273i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 139 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(274i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 140 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(279i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 141 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(280i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 142 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(670i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 143 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(286i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 144 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(288i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 145 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(289i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 146 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(296i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 147 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(735i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 148 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(298i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 149 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(299i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 150 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(319i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 151 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(300i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 152 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(729i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 153 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(301i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 154 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(302i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 155 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(303i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 156 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 157 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(712i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 158 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(305i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 159 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(306i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 160 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(307i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 161 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(308i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 162 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(309i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 163 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(310i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 164 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(312i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 165 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(311i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 166 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(313i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 167 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(314i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 168 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 169 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(738i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 170 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(317i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 171 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(318i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 172 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(736i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 173 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(321i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 174 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(322i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 175 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 176 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(324i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 177 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(327i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 178 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(328i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 179 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(333i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 180 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 181 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(335i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 182 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(336i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 183 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(337i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 184 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(340i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 185 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(343i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 186 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(344i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 187 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(346i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 188 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(348i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 189 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(350i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 190 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(351i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 191 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(352i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 192 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(353i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 193 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(354i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 194 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(355i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 195 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 196 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(357i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 197 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(358i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 198 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(361i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 199 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(363i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 200 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(702i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 201 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(365i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 202 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(366i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 203 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(367i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 204 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(368i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 205 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(671i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 206 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(374i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 207 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 208 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(377i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 209 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(379i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 210 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(381i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 211 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(732i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 212 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(728i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 213 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(384i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 214 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 215 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(387i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 216 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(719i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 217 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(390i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 218 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 219 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(717i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 220 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(690i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 221 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(398i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 222 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(399i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 223 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(400i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 224 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(401i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 225 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(402i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 226 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 227 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 228 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 229 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(704i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 230 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(407i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 231 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(408i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 232 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(409i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 233 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(410i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 234 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(411i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 235 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 236 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 237 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 238 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 239 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(419i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 240 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(421i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 241 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(737i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 242 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(424i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 243 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(426i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 244 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 245 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(429i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 246 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(430i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 247 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 248 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(434i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 249 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(438i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 250 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(439i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 251 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(441i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 252 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(846i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 253 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(442i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 254 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(718i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 255 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(445i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 256 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(446i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 257 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(447i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 258 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(448i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 259 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(449i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 260 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(452i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 261 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(842i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 262 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(454i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 263 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(456i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 264 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(460i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 265 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(462i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 266 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(461i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 267 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(463i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 268 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(466i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 269 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(464i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 270 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(465i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 271 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(617i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 272 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(695i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 273 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(470i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 274 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(472i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 275 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(727i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 276 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(473i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 277 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(851i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 278 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(474i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 279 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(706i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 280 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(476i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 281 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(659i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 282 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(481i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 283 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(482i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 284 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 285 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(485i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 286 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(486i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 287 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(488i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 288 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(490i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 289 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(492i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 290 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 291 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(849i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 292 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(722i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 293 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(720i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 294 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 295 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(495i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 296 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 297 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(500i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 298 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 299 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(503i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 300 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(508i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 301 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 302 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(669i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 303 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(515i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 304 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 305 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 306 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(520i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 307 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(521i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 308 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(813i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 309 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(814i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 310 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(815i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 311 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(817i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 312 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(816i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 313 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(818i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 314 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(819i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 315 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(820i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 316 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(821i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 317 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(822i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 318 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(823i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 319 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(824i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 320 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(825i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 321 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(826i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 322 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(829i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 323 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(828i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 324 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(830i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 325 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(831i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 326 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(833i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 327 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(832i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 328 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(834i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 329 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(827i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 330 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(835i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 331 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(522i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 332 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(836i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 333 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(837i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 334 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(838i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 335 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(839i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 336 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(528i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 337 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(529i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 338 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(530i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 339 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(532i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 340 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(535i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 341 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(538i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 342 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(707i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 343 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(540i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 344 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(542i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 345 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(544i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 346 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(545i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 347 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(546i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 348 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 349 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(553i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 350 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(556i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 351 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 352 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(558i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 353 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(559i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 354 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(560i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 355 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(561i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 356 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(566i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 357 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(567i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 358 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(568i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 359 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 360 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 361 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(575i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 362 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(576i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 363 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 364 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(578i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 365 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(580i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 366 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(581i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 367 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(708i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 368 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 369 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(584i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 370 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(585i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 371 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 372 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 373 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(845i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 374 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(592i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 375 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(593i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 376 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(598i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 377 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(599i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 378 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(698i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 379 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(601i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 380 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(602i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 381 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(603i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 382 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(604i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 383 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(610i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 384 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(613i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 385 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(615i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 386 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 387 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(619i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 388 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(625i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 389 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 390 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(631i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 391 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(711i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 392 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 393 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(662i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 394 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(638i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 395 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(639i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 396 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(640i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 397 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(641i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 398 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(646i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 399 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(647i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 400 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(648i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 401 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(650i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 402 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(652i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 403 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 404 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(656i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 405 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(843i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1283 + fn parse_rule_3896(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 583i64 | 586i64 | 731i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(731i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(741i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(735i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(738i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(736i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(733i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(744i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(740i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(737i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(734i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(739i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(742i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(743i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1284 + fn parse_rule_3897(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 583i64 | 586i64 | 731i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3896i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleKeyword + fn parse_rule_3898(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | + 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | + 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | + 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | + 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | + 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | + 848i64 | 849i64 | 850i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3898i64); + } + self.parse_child(3899i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3898i64); + } + self.parse_child(3901i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1285 + fn parse_rule_3899(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | + 671i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 711i64 | 712i64 | 716i64 | 717i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3908i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3904i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1286 + fn parse_rule_3900(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 13i64 | 16i64 | 19i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | + 29i64 | 33i64 | 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | + 65i64 | 66i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | + 87i64 | 88i64 | 89i64 | 90i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | + 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | + 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | + 197i64 | 201i64 | 202i64 | 204i64 | 206i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | + 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | + 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | + 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | + 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | + 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 387i64 | 390i64 | + 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | + 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | + 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | + 480i64 | 481i64 | 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | + 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | + 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | + 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | + 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | + 671i64 | 674i64 | 675i64 | 676i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | + 707i64 | 708i64 | 711i64 | 712i64 | 716i64 | 717i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3899i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1287 + fn parse_rule_3901(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 19i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 29i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | + 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | + 89i64 | 90i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | + 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | + 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | 202i64 | 204i64 | 208i64 | + 210i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | 243i64 | + 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | + 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | + 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | + 368i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | 404i64 | 406i64 | + 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | + 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 452i64 | 454i64 | 455i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | + 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | 483i64 | 485i64 | 486i64 | 488i64 | 489i64 | 490i64 | + 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 502i64 | 503i64 | 508i64 | 512i64 | 513i64 | 514i64 | 515i64 | 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | + 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | + 560i64 | 561i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | + 593i64 | 597i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | 652i64 | 653i64 | 656i64 | 658i64 | 659i64 | 660i64 | 661i64 | + 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 673i64 | 674i64 | 675i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | + 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 713i64 | 715i64 | 716i64 | 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | + 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | + 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | + 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | + 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3894i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3888i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3903i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // lValueKeyword + fn parse_rule_3902(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 12i64 | 16i64 | 19i64 | 21i64 | 23i64 | 24i64 | 25i64 | 26i64 | 27i64 | 29i64 | 33i64 | + 37i64 | 40i64 | 41i64 | 42i64 | 44i64 | 46i64 | 47i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 58i64 | 61i64 | 63i64 | 64i64 | 65i64 | 66i64 | + 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 75i64 | 76i64 | 77i64 | 78i64 | 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | + 89i64 | 90i64 | 91i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | 122i64 | 123i64 | 129i64 | 130i64 | 132i64 | 138i64 | 139i64 | 140i64 | + 141i64 | 142i64 | 147i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 159i64 | 160i64 | 162i64 | 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 170i64 | + 171i64 | 172i64 | 173i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 188i64 | 189i64 | 190i64 | 191i64 | 192i64 | 196i64 | 197i64 | 201i64 | + 202i64 | 204i64 | 208i64 | 210i64 | 211i64 | 212i64 | 213i64 | 216i64 | 219i64 | 220i64 | 222i64 | 224i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | + 238i64 | 243i64 | 244i64 | 245i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 267i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | + 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | + 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | + 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | + 367i64 | 368i64 | 369i64 | 373i64 | 374i64 | 377i64 | 379i64 | 381i64 | 384i64 | 386i64 | 387i64 | 390i64 | 398i64 | 399i64 | 400i64 | 401i64 | 402i64 | 403i64 | + 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 413i64 | 415i64 | 417i64 | 418i64 | 419i64 | 421i64 | 423i64 | 424i64 | 425i64 | 426i64 | + 427i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 451i64 | 452i64 | 454i64 | 455i64 | + 456i64 | 459i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 468i64 | 470i64 | 472i64 | 473i64 | 474i64 | 476i64 | 480i64 | 481i64 | 482i64 | + 483i64 | 485i64 | 486i64 | 488i64 | 489i64 | 490i64 | 492i64 | 495i64 | 496i64 | 500i64 | 501i64 | 503i64 | 508i64 | 510i64 | 512i64 | 513i64 | 514i64 | 515i64 | + 517i64 | 519i64 | 520i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 535i64 | 538i64 | 540i64 | 542i64 | 543i64 | 544i64 | 545i64 | 546i64 | 547i64 | + 552i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | + 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 597i64 | 598i64 | 599i64 | 601i64 | 602i64 | 603i64 | 604i64 | 606i64 | 607i64 | 610i64 | + 613i64 | 615i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 648i64 | 650i64 | 651i64 | + 652i64 | 653i64 | 656i64 | 659i64 | 660i64 | 661i64 | 662i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 677i64 | 680i64 | 682i64 | 689i64 | 690i64 | + 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 709i64 | 711i64 | 712i64 | 713i64 | 714i64 | 715i64 | 716i64 | + 717i64 | 718i64 | 719i64 | 720i64 | 721i64 | 722i64 | 723i64 | 724i64 | 725i64 | 727i64 | 728i64 | 729i64 | 730i64 | 731i64 | 732i64 | 733i64 | 734i64 | 735i64 | + 736i64 | 737i64 | 738i64 | 739i64 | 740i64 | 741i64 | 742i64 | 743i64 | 744i64 | 812i64 | 813i64 | 814i64 | 815i64 | 816i64 | 817i64 | 818i64 | 819i64 | 820i64 | + 821i64 | 822i64 | 823i64 | 824i64 | 825i64 | 826i64 | 827i64 | 828i64 | 829i64 | 830i64 | 831i64 | 832i64 | 833i64 | 834i64 | 835i64 | 836i64 | 837i64 | 838i64 | + 839i64 | 840i64 | 841i64 | 842i64 | 843i64 | 844i64 | 845i64 | 846i64 | 847i64 | 848i64 | 849i64 | 851i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3902i64); + } + self.parse_child(3894i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3902i64); + } + self.parse_child(3887i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3902i64); + } + self.parse_child(3888i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3902i64); + } + self.parse_child(3893i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // identifierKeywordsAmbiguous4SystemVariables + fn parse_rule_3903(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 214i64 | 284i64 | 502i64 | 658i64 | 673i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3903i64); + } + self.parse_child(214i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3903i64); + } + self.parse_child(284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3903i64); + } + self.parse_child(658i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3903i64); + } + self.parse_child(673i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3903i64); + } + self.parse_child(502i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleOrIdentifierKeyword + fn parse_rule_3904(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 12i64 | 19i64 | 27i64 | 29i64 | 46i64 | 47i64 | 58i64 | 61i64 | 66i64 | 75i64 | 77i64 | 90i64 | 123i64 | 147i64 | 159i64 | 196i64 | 197i64 | + 201i64 | 210i64 | 219i64 | 222i64 | 224i64 | 234i64 | 245i64 | 267i64 | 373i64 | 387i64 | 390i64 | 398i64 | 401i64 | 413i64 | 415i64 | 417i64 | 452i64 | 455i64 | + 468i64 | 470i64 | 480i64 | 489i64 | 496i64 | 503i64 | 510i64 | 512i64 | 514i64 | 519i64 | 520i64 | 543i64 | 552i64 | 597i64 | 606i64 | 607i64 | 615i64 | 648i64 | + 651i64 | 659i64 | 661i64 | 662i64 | 677i64 | 720i64 | 721i64 | 722i64 | 723i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3904i64); + } + self.parse_child(3905i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3904i64); + } + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3904i64); + } + self.parse_child(234i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1288 + fn parse_rule_3905(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 2i64 | 12i64 | 19i64 | 27i64 | 29i64 | 46i64 | 47i64 | 58i64 | 61i64 | 66i64 | 75i64 | 77i64 | 90i64 | 123i64 | 147i64 | 159i64 | 196i64 | 197i64 | + 201i64 | 210i64 | 219i64 | 222i64 | 224i64 | 245i64 | 267i64 | 373i64 | 387i64 | 390i64 | 398i64 | 401i64 | 413i64 | 415i64 | 417i64 | 452i64 | 455i64 | 468i64 | + 470i64 | 480i64 | 489i64 | 496i64 | 503i64 | 512i64 | 514i64 | 519i64 | 520i64 | 543i64 | 552i64 | 597i64 | 606i64 | 607i64 | 615i64 | 648i64 | 651i64 | 659i64 | + 661i64 | 662i64 | 677i64 | 720i64 | 721i64 | 722i64 | 723i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(2i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(19i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(12i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(27i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(29i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(46i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(47i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(58i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(61i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(677i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(66i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(75i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(77i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(90i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(123i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(147i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(159i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(196i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(197i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(201i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(210i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(219i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(222i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(224i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(245i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(661i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(267i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(373i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(387i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(390i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(398i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(401i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(413i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(415i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 34 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(417i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 35 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(452i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 36 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(455i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 37 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(468i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 38 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(470i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 39 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(659i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 40 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(480i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 41 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(489i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 42 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(720i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 43 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(721i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 44 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(722i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 45 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(723i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 46 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(496i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 47 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(503i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 48 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(512i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 49 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(519i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 50 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(514i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 51 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(520i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 52 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(543i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 53 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(552i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 54 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(597i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 55 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(606i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 56 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(607i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 57 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(615i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 58 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(662i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 59 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(648i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 60 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(651i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1289 + fn parse_rule_3906(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 510i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1290 + fn parse_rule_3907(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 234i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(234i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // roleOrLabelKeyword + fn parse_rule_3908(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 33i64 | 37i64 | 40i64 | 41i64 | + 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 78i64 | + 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 99i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | + 116i64 | 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | + 163i64 | 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 172i64 | 176i64 | 177i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | + 192i64 | 202i64 | 204i64 | 206i64 | 208i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 220i64 | 225i64 | 229i64 | 230i64 | 233i64 | 234i64 | 235i64 | 238i64 | + 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | + 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | + 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | + 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | + 368i64 | 374i64 | 377i64 | 379i64 | 381i64 | 382i64 | 384i64 | 386i64 | 399i64 | 400i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | + 411i64 | 412i64 | 418i64 | 419i64 | 421i64 | 424i64 | 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | + 446i64 | 447i64 | 448i64 | 449i64 | 454i64 | 456i64 | 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 472i64 | 473i64 | 474i64 | 476i64 | 481i64 | + 482i64 | 483i64 | 484i64 | 485i64 | 486i64 | 487i64 | 488i64 | 490i64 | 492i64 | 495i64 | 500i64 | 501i64 | 502i64 | 508i64 | 510i64 | 513i64 | 515i64 | 517i64 | + 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | 540i64 | 542i64 | 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | + 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | + 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | 603i64 | 604i64 | 610i64 | 613i64 | 617i64 | 618i64 | 619i64 | 625i64 | 627i64 | + 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 646i64 | 647i64 | 650i64 | 652i64 | 653i64 | 656i64 | 660i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | + 675i64 | 676i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | + 712i64 | 716i64 | 717i64 | 719i64 | 724i64 | 725i64 | 727i64 | 728i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3908i64); + } + self.parse_child(3909i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3908i64); + } + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3908i64); + } + self.parse_child(3911i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3908i64); + } + self.parse_child(3913i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + if !skip_current_node { + self.push_node(3908i64); + } + self.parse_child(660i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1291 + fn parse_rule_3909(&mut self, skip_current_node: bool) -> CompiledMatch { + if !( +matches!( + self.current_token_id(), + 3i64 | 5i64 | 6i64 | 7i64 | 8i64 | 9i64 | 13i64 | 16i64 | 21i64 | 22i64 | 23i64 | 24i64 | 25i64 | 26i64 | 33i64 | 37i64 | 40i64 | 41i64 | + 42i64 | 44i64 | 50i64 | 53i64 | 54i64 | 56i64 | 57i64 | 63i64 | 64i64 | 65i64 | 67i64 | 68i64 | 70i64 | 71i64 | 73i64 | 74i64 | 76i64 | 78i64 | + 79i64 | 80i64 | 81i64 | 82i64 | 84i64 | 85i64 | 87i64 | 88i64 | 89i64 | 91i64 | 93i64 | 96i64 | 101i64 | 107i64 | 111i64 | 112i64 | 113i64 | 116i64 | + 122i64 | 129i64 | 130i64 | 132i64 | 136i64 | 138i64 | 139i64 | 140i64 | 141i64 | 142i64 | 150i64 | 151i64 | 152i64 | 156i64 | 158i64 | 160i64 | 162i64 | 163i64 | + 164i64 | 165i64 | 166i64 | 168i64 | 169i64 | 171i64 | 176i64 | 179i64 | 180i64 | 181i64 | 184i64 | 185i64 | 189i64 | 190i64 | 191i64 | 192i64 | 202i64 | 204i64 | + 208i64 | 211i64 | 212i64 | 213i64 | 214i64 | 216i64 | 220i64 | 225i64 | 229i64 | 230i64 | 233i64 | 235i64 | 238i64 | 243i64 | 244i64 | 250i64 | 255i64 | 256i64 | + 258i64 | 259i64 | 262i64 | 264i64 | 268i64 | 270i64 | 273i64 | 274i64 | 279i64 | 280i64 | 284i64 | 286i64 | 288i64 | 289i64 | 296i64 | 298i64 | 299i64 | 300i64 | + 301i64 | 302i64 | 303i64 | 304i64 | 305i64 | 306i64 | 307i64 | 308i64 | 309i64 | 310i64 | 311i64 | 312i64 | 313i64 | 314i64 | 316i64 | 317i64 | 318i64 | 319i64 | + 321i64 | 322i64 | 323i64 | 324i64 | 325i64 | 327i64 | 328i64 | 333i64 | 334i64 | 335i64 | 336i64 | 337i64 | 340i64 | 343i64 | 344i64 | 346i64 | 348i64 | 350i64 | + 351i64 | 352i64 | 353i64 | 354i64 | 355i64 | 356i64 | 357i64 | 358i64 | 361i64 | 363i64 | 365i64 | 366i64 | 367i64 | 368i64 | 374i64 | 377i64 | 379i64 | 381i64 | + 382i64 | 384i64 | 399i64 | 400i64 | 402i64 | 403i64 | 404i64 | 406i64 | 407i64 | 408i64 | 409i64 | 410i64 | 411i64 | 412i64 | 418i64 | 419i64 | 421i64 | 424i64 | + 425i64 | 426i64 | 429i64 | 430i64 | 431i64 | 434i64 | 438i64 | 439i64 | 440i64 | 441i64 | 442i64 | 445i64 | 446i64 | 447i64 | 448i64 | 449i64 | 454i64 | 456i64 | + 460i64 | 461i64 | 462i64 | 463i64 | 464i64 | 465i64 | 466i64 | 472i64 | 473i64 | 474i64 | 476i64 | 481i64 | 482i64 | 483i64 | 485i64 | 486i64 | 488i64 | 490i64 | + 492i64 | 495i64 | 500i64 | 501i64 | 502i64 | 508i64 | 513i64 | 515i64 | 517i64 | 521i64 | 522i64 | 528i64 | 529i64 | 530i64 | 532i64 | 533i64 | 535i64 | 538i64 | + 540i64 | 542i64 | 544i64 | 545i64 | 546i64 | 547i64 | 553i64 | 556i64 | 557i64 | 558i64 | 559i64 | 560i64 | 561i64 | 565i64 | 566i64 | 567i64 | 568i64 | 571i64 | + 572i64 | 575i64 | 576i64 | 577i64 | 578i64 | 580i64 | 581i64 | 583i64 | 584i64 | 585i64 | 586i64 | 592i64 | 593i64 | 598i64 | 599i64 | 600i64 | 601i64 | 602i64 | + 603i64 | 604i64 | 610i64 | 613i64 | 617i64 | 618i64 | 619i64 | 627i64 | 631i64 | 636i64 | 638i64 | 639i64 | 640i64 | 641i64 | 647i64 | 650i64 | 652i64 | 653i64 | + 656i64 | 664i64 | 669i64 | 670i64 | 671i64 | 674i64 | 675i64 | 676i64 | 680i64 | 682i64 | 689i64 | 690i64 | 693i64 | 695i64 | 697i64 | 698i64 | 702i64 | 703i64 | + 704i64 | 705i64 | 706i64 | 707i64 | 708i64 | 711i64 | 712i64 | 716i64 | 717i64 | 719i64 | 724i64 | 725i64 | 727i64 | 728i64 | 850i64 + ) + ) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(724i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(5i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(6i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(7i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(8i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 6 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(9i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 7 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(13i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 8 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(16i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 9 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(21i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 10 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(22i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 11 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(24i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 12 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(23i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 13 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(25i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 14 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(26i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 15 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(33i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 16 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(37i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 17 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(40i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 18 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(42i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 19 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(41i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 20 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(44i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 21 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(675i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 22 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(50i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 23 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(53i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 24 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(54i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 25 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(56i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 26 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(57i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 27 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(63i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 28 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(65i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 29 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(64i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 30 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(67i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 31 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(68i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 32 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(70i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 33 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(73i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 34 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(74i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 35 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(71i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 36 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(76i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 37 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(78i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 38 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(79i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 39 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(664i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 40 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(80i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 41 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(81i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 42 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(82i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 43 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(84i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 44 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(85i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 45 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(87i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 46 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(89i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 47 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(88i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 48 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(91i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 49 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(93i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 50 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(96i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 51 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(101i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 52 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(107i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 53 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(112i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 54 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(111i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 55 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(113i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 56 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(116i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 57 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(122i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 58 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(129i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 59 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(130i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 60 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(132i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 61 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(136i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 62 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(716i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 63 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(138i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 64 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(139i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 65 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(140i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 66 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(141i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 67 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(142i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 68 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(150i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 69 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(151i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 70 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(152i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 71 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(158i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 72 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(160i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 73 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(164i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 74 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(163i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 75 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(162i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 76 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(165i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 77 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(166i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 78 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(168i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 79 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(169i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 80 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(171i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 81 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(680i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 82 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(176i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 83 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(179i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 84 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(180i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 85 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(181i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 86 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(185i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 87 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(184i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 88 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(682i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 89 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(202i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 90 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(156i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 91 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(204i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 92 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(189i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 93 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(190i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 94 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(191i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 95 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(192i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 96 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(208i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 97 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(212i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 98 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(211i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 99 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(213i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 100 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(216i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 101 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(214i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 102 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(220i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 103 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(674i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 104 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(705i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 105 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(225i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 106 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(229i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 107 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(230i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 108 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(233i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 109 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(250i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 110 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(235i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 111 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(238i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 112 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(244i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 113 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(725i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 114 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(255i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 115 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(256i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 116 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(258i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 117 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(259i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 118 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(243i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 119 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(262i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 120 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(850i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 121 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(264i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 122 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(268i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 123 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(270i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 124 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(273i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 125 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(274i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 126 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(279i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 127 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(280i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 128 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(284i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 129 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(670i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 130 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(286i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 131 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(288i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 132 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(289i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 133 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(323i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 134 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(316i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 135 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(319i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 136 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(300i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 137 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(304i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 138 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(301i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 139 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(302i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 140 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(318i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 141 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(303i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 142 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(712i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 143 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(306i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 144 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(298i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 145 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(305i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 146 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(299i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 147 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(314i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 148 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(308i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 149 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(307i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 150 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(317i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 151 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(309i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 152 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(310i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 153 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(311i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 154 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(312i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 155 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(313i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 156 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(296i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 157 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(321i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 158 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(322i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 159 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(325i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 160 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(324i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 161 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(327i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 162 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(328i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 163 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(333i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 164 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(334i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 165 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(335i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 166 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(336i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 167 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(337i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 168 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(340i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 169 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(343i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 170 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(344i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 171 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(348i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 172 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(346i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 173 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(350i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 174 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(351i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 175 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(352i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 176 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(353i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 177 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(354i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 178 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(355i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 179 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(357i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 180 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(356i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 181 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(358i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 182 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(361i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 183 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(363i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 184 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(702i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 185 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(365i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 186 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(367i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 187 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(366i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 188 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(374i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 189 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(368i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 190 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(689i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 191 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(671i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 192 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(377i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 193 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(379i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 194 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(381i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 195 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(728i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 196 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(382i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 197 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(384i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 198 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(719i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 199 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(703i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 200 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(717i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 201 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(690i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 202 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(399i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 203 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(400i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 204 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(402i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 205 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(403i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 206 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(404i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 207 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(406i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 208 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(704i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 209 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(407i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 210 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(409i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 211 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(410i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 212 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(408i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 213 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(411i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 214 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(412i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 215 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(693i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 216 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(418i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 217 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(419i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 218 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(708i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 219 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(421i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 220 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(424i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 221 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(425i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 222 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(426i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 223 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(429i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 224 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(430i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 225 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(431i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 226 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(434i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 227 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(438i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 228 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(439i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 229 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(441i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 230 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(440i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 231 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(442i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 232 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(445i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 233 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(446i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 234 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(447i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 235 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(448i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 236 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(449i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 237 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(676i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 238 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(454i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 239 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(456i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 240 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(460i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 241 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(461i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 242 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(462i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 243 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(463i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 244 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(464i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 245 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(465i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 246 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(466i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 247 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(617i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 248 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(695i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 249 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(472i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 250 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(727i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 251 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(473i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 252 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(474i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 253 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(706i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 254 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(476i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 255 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(481i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 256 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(482i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 257 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(483i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 258 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(485i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 259 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(486i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 260 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(488i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 261 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(490i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 262 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(492i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 263 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(495i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 264 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(501i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 265 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(500i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 266 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(502i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 267 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(508i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 268 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(513i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 269 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(669i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 270 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(515i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 271 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(517i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 272 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(521i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 273 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(522i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 274 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(528i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 275 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(529i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 276 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(530i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 277 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(533i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 278 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(532i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 279 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(535i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 280 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(538i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 281 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(707i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 282 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(540i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 283 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(542i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 284 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(544i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 285 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(545i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 286 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(546i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 287 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(547i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 288 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(553i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 289 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(556i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 290 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(557i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 291 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(558i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 292 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(559i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 293 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(561i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 294 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(560i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 295 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 296 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(566i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 297 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(567i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 298 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(568i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 299 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(576i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 300 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(571i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 301 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(575i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 302 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(572i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 303 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(577i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 304 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(578i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 305 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(580i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 306 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(581i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 307 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(697i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 308 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(592i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 309 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(593i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 310 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(583i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 311 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(584i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 312 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(585i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 313 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(586i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 314 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(598i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 315 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(599i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 316 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(600i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 317 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(698i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 318 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(601i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 319 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(602i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 320 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(604i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 321 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(603i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 322 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(610i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 323 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(613i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 324 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(618i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 325 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(619i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 326 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(631i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 327 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(711i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 328 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(636i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 329 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(627i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 330 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(639i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 331 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(638i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 332 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(640i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 333 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(647i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 334 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(641i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 335 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(650i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 336 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(652i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 337 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(653i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 338 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(656i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1292 + fn parse_rule_3910(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 510i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(510i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1293 + fn parse_rule_3911(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 99i64 | 206i64 | 234i64 | 484i64 | 487i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(99i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(234i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(206i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(484i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(487i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1294 + fn parse_rule_3912(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 99i64 | 206i64 | 234i64 | 484i64 | 487i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3911i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1295 + fn parse_rule_3913(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 172i64 | 177i64 | 386i64 | 565i64 | 625i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(172i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 1 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(177i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 2 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(386i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 3 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(565i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 4 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(625i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + // branch 5 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(646i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1296 + fn parse_rule_3914(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 172i64 | 177i64 | 386i64 | 565i64 | 625i64 | 646i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(3913i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } + + // %f1297 + fn parse_rule_3915(&mut self, skip_current_node: bool) -> CompiledMatch { + if !matches!(self.current_token_id(), 660i64) { + return CompiledMatch::No; + } + + let starting_state = self.state(); + // branch 0 + self.restore(starting_state); + let mut branch_matches = true; + let mut has_children = false; + self.parse_child(660i64, &mut branch_matches, &mut has_children); + if branch_matches { + if has_children { + return CompiledMatch::Match; + } + self.restore(starting_state); + return CompiledMatch::Empty; + } + + self.restore(starting_state); + CompiledMatch::No + } +} diff --git a/packages/php-ext-wp-mysql-parser/src/lib.rs b/packages/php-ext-wp-mysql-parser/src/lib.rs index 2a2e8f360..c40c8cef8 100644 --- a/packages/php-ext-wp-mysql-parser/src/lib.rs +++ b/packages/php-ext-wp-mysql-parser/src/lib.rs @@ -16,9 +16,16 @@ use ext_php_rs::types::{ArrayKey, ZendCallable, ZendHashTable, ZendObject, Zval} use ext_php_rs::zend::{ClassEntry, ModuleEntry}; use ext_php_rs::{info_table_end, info_table_row, info_table_start}; +#[rustfmt::skip] +mod compiled_packed_id_parser; mod lexer_constants; +mod native_sqlite_connection; +mod native_sqlite_translator; use lexer_constants as lex; use lexer_constants::register_lexer_constants; +use native_sqlite_connection::{ + WpSqliteNativeConnection, WpSqliteNativePackedResult, WpSqliteNativeStatement, +}; const SQL_MODE_HIGH_NOT_PRECEDENCE: i64 = 1; const SQL_MODE_PIPES_AS_CONCAT: i64 = 2; @@ -180,20 +187,34 @@ fn span_until(bytes: &[u8], mut pos: usize, needles: &[u8]) -> usize { pos } -fn bytes_ascii_upper(bytes: &[u8]) -> String { - let mut upper = Vec::with_capacity(bytes.len()); - upper.extend(bytes.iter().map(u8::to_ascii_uppercase)); +fn bytes_ascii_lower(bytes: &[u8]) -> String { + let mut lower = Vec::with_capacity(bytes.len()); + lower.extend(bytes.iter().map(u8::to_ascii_lowercase)); // The lexer only calls this for identifier slices. ASCII bytes remain // ASCII and non-ASCII identifier bytes have already passed the UTF-8 // shape checks in read_identifier(). - unsafe { String::from_utf8_unchecked(upper) } + unsafe { String::from_utf8_unchecked(lower) } } -fn bytes_ascii_lower(bytes: &[u8]) -> String { - let mut lower = Vec::with_capacity(bytes.len()); - lower.extend(bytes.iter().map(u8::to_ascii_lowercase)); - // See bytes_ascii_upper(). - unsafe { String::from_utf8_unchecked(lower) } +fn keyword_token_ascii_case_insensitive(value: &[u8]) -> Option { + if !value.is_ascii() { + return None; + } + + let mut buffer = [0u8; 128]; + if value.len() <= buffer.len() { + for (index, byte) in value.iter().enumerate() { + buffer[index] = byte.to_ascii_uppercase(); + } + // ASCII bytes are valid UTF-8 and the buffer slice is initialized above. + let keyword = unsafe { std::str::from_utf8_unchecked(&buffer[..value.len()]) }; + return lex::keyword_token(keyword); + } + + let mut upper = Vec::with_capacity(value.len()); + upper.extend(value.iter().map(u8::to_ascii_uppercase)); + // ASCII bytes are valid UTF-8. + lex::keyword_token(unsafe { std::str::from_utf8_unchecked(&upper) }) } #[derive(Clone, Copy)] @@ -247,16 +268,12 @@ impl WpMySqlNativeLexer { .into_zval(false) .map_err(php_error)?; - Ok(Self { + Ok(Self::from_sql_parts( sql, sql_zval, mysql_version, - sql_modes: sql_modes_mask(&sql_modes), - bytes_already_read: 0, - token_starts_at: 0, - token_type: None, - in_mysql_comment: false, - }) + sql_modes, + )) } pub fn next_token(&mut self) -> bool { @@ -333,9 +350,95 @@ impl WpMySqlNativeLexer { pub fn get_token_name(token_id: i64) -> Option { lex::token_name(token_id).map(ToOwned::to_owned) } + + pub fn translate_sqlite_plan(sql: &Zval) -> PhpResult>> { + Ok(native_sqlite_translator::translate_sqlite_plan( + &zval_to_weak_string_bytes(sql)?, + )) + } + + pub fn translate_sqlite_plan_code(sql: &Zval) -> PhpResult { + Ok(native_sqlite_translator::translate_sqlite_plan_code( + &zval_to_weak_string_bytes(sql)?, + )) + } } impl WpMySqlNativeLexer { + fn from_sql_parts( + sql: Vec, + sql_zval: Zval, + mysql_version: i64, + sql_modes: Vec, + ) -> Self { + Self::from_sql_parts_with_modes_mask( + sql, + sql_zval, + mysql_version, + sql_modes_mask(&sql_modes), + ) + } + + fn from_sql_parts_with_modes_mask( + sql: Vec, + sql_zval: Zval, + mysql_version: i64, + sql_modes: i64, + ) -> Self { + Self { + sql, + sql_zval, + mysql_version, + sql_modes, + bytes_already_read: 0, + token_starts_at: 0, + token_type: None, + in_mysql_comment: false, + } + } + + fn from_raw_sql_zval_with_modes_mask( + sql: &Zval, + mysql_version: Option, + sql_modes: i64, + ) -> PhpResult { + Ok(Self::from_sql_parts_with_modes_mask( + zval_to_weak_string_bytes(sql)?, + Zval::null(), + mysql_version.unwrap_or(80038), + sql_modes, + )) + } + + fn into_raw_token_source(mut self) -> (ParserTokenSource, Vec) { + let no_backslash = self.is_sql_mode_active(SQL_MODE_NO_BACKSLASH_ESCAPES); + let mut tokens = Vec::with_capacity(self.sql.len().saturating_div(4).max(1)); + while self.next_token() { + if let Some(token) = self.current_token_info() { + tokens.push(token); + } + } + let token_ids = tokens.iter().map(|token| token.id).collect(); + ( + ParserTokenSource::RawSql { + sql: self.sql, + tokens, + no_backslash, + }, + token_ids, + ) + } + + fn into_token_ids(mut self) -> Vec { + let mut token_ids = Vec::with_capacity(self.sql.len().saturating_div(4).max(1)); + while self.next_token() { + if let Some(token_id) = self.token_type { + token_ids.push(token_id); + } + } + token_ids + } + fn current_token_info(&self) -> Option { self.token_type.map(|id| TokenInfo { id, @@ -869,10 +972,11 @@ impl WpMySqlNativeLexer { fn determine_identifier_or_keyword_type(&mut self, start: usize, end: usize) -> i64 { let value = &self.sql[start..end]; - let upper; let keyword = if value.iter().any(u8::is_ascii_lowercase) { - upper = bytes_ascii_upper(value); - upper.as_str() + match keyword_token_ascii_case_insensitive(value) { + Some(token_type) => return self.determine_keyword_type(token_type), + None => return lex::IDENTIFIER, + } } else { match std::str::from_utf8(value) { Ok(value) => value, @@ -880,11 +984,15 @@ impl WpMySqlNativeLexer { } }; - let mut token_type = match lex::keyword_token(keyword) { + let token_type = match lex::keyword_token(keyword) { Some(token_type) => token_type, None => return lex::IDENTIFIER, }; + self.determine_keyword_type(token_type) + } + + fn determine_keyword_type(&mut self, mut token_type: i64) -> i64 { if let Some(version) = lex::version_rule(token_type) { if self.mysql_version < version || -version >= self.mysql_version { return lex::IDENTIFIER; @@ -1021,9 +1129,22 @@ enum ParserTokenSource { tokens: Vec, no_backslash: bool, }, + RawSql { + sql: Vec, + tokens: Vec, + no_backslash: bool, + }, } impl ParserTokenSource { + fn sql_bytes(&self) -> Option> { + match self { + Self::Native { sql_zval, .. } => sql_zval.binary::(), + Self::RawSql { sql, .. } => Some(sql.clone()), + Self::Php(_) => None, + } + } + fn create_php_token_with_classes(&self, index: usize, classes: &PhpClasses) -> PhpResult { match self { Self::Php(tokens) => tokens @@ -1041,6 +1162,20 @@ impl ParserTokenSource { .ok_or_else(|| php_error("Parser token index is out of range"))?; create_mysql_token_with_classes(sql_zval, token, *no_backslash, classes) } + Self::RawSql { + sql, + tokens, + no_backslash, + } => { + let token = tokens + .get(index) + .copied() + .ok_or_else(|| php_error("Parser token index is out of range"))?; + let sql_zval = BinaryString(sql.clone()) + .into_zval(false) + .map_err(php_error)?; + create_mysql_token_with_classes(&sql_zval, token, *no_backslash, classes) + } } } @@ -1073,6 +1208,10 @@ impl ParserTokenSource { .get(index) .copied() .ok_or_else(|| php_error("Parser token index is out of range")), + Self::RawSql { tokens, .. } => tokens + .get(index) + .copied() + .ok_or_else(|| php_error("Parser token index is out of range")), } } } @@ -1099,6 +1238,289 @@ enum NativeParseMatch { Fragment(Vec), } +#[derive(Clone, Copy)] +enum NativeAstRowFormat { + Id, + PackedId, + Scalar, + PackedScalar, +} + +enum NativeDirectParseMatch { + No, + Empty, + Match, +} + +#[derive(Clone, Copy)] +enum NativeAstStatsFormat { + PackedId, + PackedScalar { consume_token_bytes: bool }, +} + +struct NativeAstRows { + rows: Vec, + format: NativeAstRowFormat, +} + +struct NativeAstStats { + descendants: i64, + checksum: i64, + format: NativeAstStatsFormat, + sql_bytes: Option>, +} + +impl NativeAstRowFormat { + fn estimated_elements_per_token(self) -> usize { + match self { + Self::PackedId => 8, + Self::Id | Self::PackedScalar => 16, + Self::Scalar => 32, + } + } +} + +impl NativeAstRows { + fn with_token_capacity(token_count: usize, format: NativeAstRowFormat) -> Self { + Self { + rows: Vec::with_capacity( + token_count.saturating_mul(format.estimated_elements_per_token()), + ), + format, + } + } + + fn len(&self) -> usize { + self.rows.len() + } + + fn truncate(&mut self, len: usize) { + self.rows.truncate(len); + } + + fn push_node(&mut self, rule_id: i64) { + match self.format { + NativeAstRowFormat::Id => { + self.rows.push(0); + self.rows.push(rule_id); + } + NativeAstRowFormat::PackedId => { + self.rows.push(native_ast_pack_kind_id(0, rule_id)); + } + NativeAstRowFormat::Scalar => { + self.rows.push(0); + self.rows.push(rule_id); + self.rows.push(-1); + self.rows.push(0); + } + NativeAstRowFormat::PackedScalar => { + self.rows.push(native_ast_pack_kind_id(0, rule_id)); + self.rows.push(-1); + } + } + } + + fn push_token(&mut self, token: TokenInfo) { + match self.format { + NativeAstRowFormat::Id => { + self.push_token_id(token.id); + } + NativeAstRowFormat::PackedId => { + self.push_token_id(token.id); + } + NativeAstRowFormat::Scalar => { + self.rows.push(1); + self.rows.push(token.id); + self.rows.push(token.start as i64); + self.rows.push(token.end.saturating_sub(token.start) as i64); + } + NativeAstRowFormat::PackedScalar => { + self.rows.push(native_ast_pack_kind_id(1, token.id)); + self.rows.push(native_ast_pack_span( + token.start, + token.end.saturating_sub(token.start), + )); + } + } + } + + fn push_token_id(&mut self, token_id: i64) { + match self.format { + NativeAstRowFormat::Id => { + self.rows.push(1); + self.rows.push(token_id); + } + NativeAstRowFormat::PackedId => { + self.rows.push(native_ast_pack_kind_id(1, token_id)); + } + NativeAstRowFormat::Scalar | NativeAstRowFormat::PackedScalar => {} + } + } + + fn into_vec(self) -> Vec { + self.rows + } +} + +impl NativeAstStats { + fn new(format: NativeAstStatsFormat, sql_bytes: Option>) -> Self { + Self { + descendants: 0, + checksum: 0, + format, + sql_bytes, + } + } + + fn state(&self) -> (i64, i64) { + (self.descendants, self.checksum) + } + + fn restore(&mut self, state: (i64, i64)) { + self.descendants = state.0; + self.checksum = state.1; + } + + fn push_node(&mut self, rule_id: i64) { + self.descendants += 1; + match self.format { + NativeAstStatsFormat::PackedId => { + self.checksum += native_ast_pack_kind_id(0, rule_id); + } + NativeAstStatsFormat::PackedScalar { .. } => { + self.checksum += native_ast_pack_kind_id(0, rule_id) - 1; + } + } + } + + fn push_token_id(&mut self, token_id: i64) { + self.descendants += 1; + self.checksum += native_ast_pack_kind_id(1, token_id); + } + + fn push_token(&mut self, token: TokenInfo) { + self.descendants += 1; + self.checksum += native_ast_pack_kind_id(1, token.id) + + token.start as i64 + + token.end.saturating_sub(token.start) as i64; + if matches!( + self.format, + NativeAstStatsFormat::PackedScalar { + consume_token_bytes: true + } + ) { + if let Some(sql_bytes) = self.sql_bytes.as_ref() { + let end = token.end.min(sql_bytes.len()); + let start = token.start.min(end); + self.checksum += checksum_bytes(&sql_bytes[start..end]); + } + } + } + + fn into_vec(self) -> Vec { + vec![self.descendants, self.checksum] + } +} + +fn checksum_bytes(bytes: &[u8]) -> i64 { + bytes.len() as i64 + bytes.iter().map(|byte| *byte as i64).sum::() +} + +// Raw-SQL packed-id stats do not need token spans, token objects, or a token +// source. Keep this path separate so the fastest benchmark only lexes token ids. +fn parse_recursive_packed_id_stats( + grammar: &Grammar, + token_ids: &[i64], + position: &mut usize, + rule_id: i64, + stats: &mut NativeAstStats, + skip_current_node: bool, +) -> NativeDirectParseMatch { + if rule_id <= grammar.highest_terminal_id { + if *position >= token_ids.len() { + return NativeDirectParseMatch::No; + } + if rule_id == 0 { + return NativeDirectParseMatch::Empty; + } + if token_ids[*position] == rule_id { + *position += 1; + stats.push_token_id(rule_id); + return NativeDirectParseMatch::Match; + } + return NativeDirectParseMatch::No; + } + + let Some(rule) = grammar.rule(rule_id) else { + return NativeDirectParseMatch::No; + }; + if rule.branches.is_empty() { + return NativeDirectParseMatch::No; + } + + if let Some(first_set) = rule.first_set.as_ref() { + let token_id = token_ids.get(*position).copied().unwrap_or(0); + if !first_set.contains(token_id) && !rule.nullable { + return NativeDirectParseMatch::No; + } + } else if !rule.nullable { + return NativeDirectParseMatch::No; + } + + let starting_position = *position; + let starting_stats = stats.state(); + + for branch in &rule.branches { + *position = starting_position; + stats.restore(starting_stats); + let emit_node = !skip_current_node && !rule.is_fragment; + if emit_node { + stats.push_node(rule_id); + } + let mut branch_matches = true; + let mut has_children = false; + + for &subrule_id in branch { + let child_starting_descendants = stats.descendants; + match parse_recursive_packed_id_stats( + grammar, token_ids, position, subrule_id, stats, false, + ) { + NativeDirectParseMatch::No => { + branch_matches = false; + break; + } + NativeDirectParseMatch::Empty => {} + NativeDirectParseMatch::Match => { + if stats.descendants != child_starting_descendants { + has_children = true; + } + } + } + } + + if branch_matches + && grammar.select_statement_rule_id == Some(rule_id) + && token_ids + .get(*position) + .is_some_and(|token_id| *token_id == lex::INTO_SYMBOL) + { + branch_matches = false; + } + + if branch_matches { + if has_children { + return NativeDirectParseMatch::Match; + } + stats.restore(starting_stats); + return NativeDirectParseMatch::Empty; + } + } + + *position = starting_position; + stats.restore(starting_stats); + NativeDirectParseMatch::No +} + struct NativeAstNode { rule_id: i64, children: Vec, @@ -1122,10 +1544,12 @@ struct NativeAstState { /// once, walk past, walk back, the mutation is still there). Each /// accessor in this extension constructs a fresh wrapper unless we /// intern it here. Arena node indexes are dense, so a vector avoids - /// hashing in hot AST-walk paths. The cache intentionally stores raw - /// wrapper pointers, not strong PHP references, so Rust can preserve - /// identity without pinning wrappers after PHP drops them. - node_cache: RefCell>>, + /// hashing in hot AST-walk paths. The vector is allocated lazily: parser + /// and scalar-row paths only create the root wrapper and never need child + /// identity lookups. The cache intentionally stores raw wrapper pointers, + /// not strong PHP references, so Rust can preserve identity without + /// pinning wrappers after PHP drops them. + node_cache: RefCell>>>, } struct NativeAstWrapperEntry { @@ -1227,12 +1651,51 @@ impl NativeAstArena { fn descendant_stack(&self, index: usize) -> PhpResult> { let node = self.node(index)?; - let mut stack = Vec::with_capacity(node.descendant_count); + let mut stack = Vec::with_capacity(node.children.len()); stack.extend(node.children.iter().rev().copied()); Ok(stack) } } +fn native_ast_child_handle(child: NativeAstChild) -> PhpResult { + let (index, is_token) = match child { + NativeAstChild::Node(index) => (index, 0_i64), + NativeAstChild::Token(index) => (index, 1_i64), + }; + let index = i64::try_from(index).map_err(php_error)?; + index + .checked_mul(2) + .and_then(|value| value.checked_add(is_token)) + .ok_or_else(|| php_error("Native AST handle is out of range")) +} + +fn native_ast_child_from_handle(handle: i64) -> PhpResult { + if handle < 0 { + return Err(php_error("Native AST handle must be non-negative")); + } + let index = usize::try_from(handle / 2).map_err(php_error)?; + if handle % 2 == 0 { + Ok(NativeAstChild::Node(index)) + } else { + Ok(NativeAstChild::Token(index)) + } +} + +fn native_ast_pack_kind_id(kind: i64, id: i64) -> i64 { + id * 2 + kind +} + +fn native_ast_pack_span(start: usize, length: usize) -> i64 { + (start as i64) * (1_i64 << 32) + length as i64 +} + +fn native_ast_node_index_from_handle(handle: i64) -> PhpResult { + match native_ast_child_from_handle(handle)? { + NativeAstChild::Node(index) => Ok(index), + NativeAstChild::Token(_) => Err(php_error("Native AST handle does not refer to a node")), + } +} + fn native_ast_wrapper_key(wrapper_zval: &Zval) -> PhpResult { let object = wrapper_zval .object() @@ -1267,8 +1730,10 @@ fn register_native_ast_wrapper( }, ); }); - if let Some(slot) = ast.node_cache.borrow_mut().get_mut(node_index) { - *slot = Some(key); + if let Some(cache) = ast.node_cache.borrow_mut().as_mut() { + if let Some(slot) = cache.get_mut(node_index) { + *slot = Some(key); + } } key } @@ -1285,9 +1750,11 @@ fn release_native_ast_wrapper_key(key: usize) { let entry = NATIVE_AST_WRAPPERS.with(|wrappers| wrappers.borrow_mut().remove(&key)); if let Some(entry) = entry { let mut cache = entry.ast.node_cache.borrow_mut(); - if let Some(slot) = cache.get_mut(entry.node_index) { - if *slot == Some(key) { - *slot = None; + if let Some(cache) = cache.as_mut() { + if let Some(slot) = cache.get_mut(entry.node_index) { + if *slot == Some(key) { + *slot = None; + } } } } @@ -1317,7 +1784,7 @@ unsafe fn zval_from_cached_object(key: usize) -> Zval { impl NativeAstState { fn new(arena: Arc) -> Rc { Rc::new(Self { - node_cache: RefCell::new(vec![None; arena.nodes.len()]), + node_cache: RefCell::new(None), arena, }) } @@ -1363,17 +1830,25 @@ impl NativeAstState { fn cached_node_zval(self: &Rc, index: usize, classes: &PhpClasses) -> PhpResult { let cached_key = { let cache = self.node_cache.borrow(); - cache.get(index).and_then(|entry| *entry) + cache + .as_ref() + .and_then(|cache| cache.get(index)) + .and_then(|entry| *entry) }; if let Some(key) = cached_key { if native_ast_wrapper_matches(key, self, index) { return Ok(unsafe { zval_from_cached_object(key) }); } - if let Some(slot) = self.node_cache.borrow_mut().get_mut(index) { - *slot = None; + if let Some(cache) = self.node_cache.borrow_mut().as_mut() { + if let Some(slot) = cache.get_mut(index) { + *slot = None; + } } } + if self.node_cache.borrow().is_none() { + *self.node_cache.borrow_mut() = Some(vec![None; self.arena.nodes.len()]); + } self.create_php_node_with_classes(index, classes) } @@ -1651,34 +2126,257 @@ pub fn wp_sqlite_mysql_native_ast_get_descendant_tokens( } #[php_function] -pub fn wp_sqlite_mysql_native_ast_get_start(wrapper_zval: &Zval) -> PhpResult { - let (ast, node_index) = native_ast_from_wrapper(wrapper_zval)?; - let node = ast.arena.node(node_index)?; - let token_index = node - .first_token - .ok_or_else(|| php_error("Native AST node has no descendant tokens"))?; - let token = ast.arena.token_source.token_info(token_index)?; - i64::try_from(token.start).map_err(php_error) +pub fn wp_sqlite_mysql_native_ast_get_native_handle(wrapper_zval: &Zval) -> PhpResult { + let (_ast, node_index) = native_ast_from_wrapper(wrapper_zval)?; + native_ast_child_handle(NativeAstChild::Node(node_index)) } #[php_function] -pub fn wp_sqlite_mysql_native_ast_get_length(wrapper_zval: &Zval) -> PhpResult { - let (ast, node_index) = native_ast_from_wrapper(wrapper_zval)?; +pub fn wp_sqlite_mysql_native_ast_get_native_child_handles( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult> { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + let node_index = native_ast_node_index_from_handle(handle)?; + ast.arena + .node(node_index)? + .children + .iter() + .copied() + .map(native_ast_child_handle) + .collect() +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_descendant_handles( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult> { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + let node_index = native_ast_node_index_from_handle(handle)?; let node = ast.arena.node(node_index)?; - let first_token_index = node - .first_token - .ok_or_else(|| php_error("Native AST node has no descendant tokens"))?; - let last_token_index = node - .last_token - .ok_or_else(|| php_error("Native AST node has no descendant tokens"))?; - let first_token = ast.arena.token_source.token_info(first_token_index)?; - let last_token = ast.arena.token_source.token_info(last_token_index)?; - let length = last_token.end.saturating_sub(first_token.start); - i64::try_from(length).map_err(php_error) + let mut descendants = Vec::with_capacity(node.descendant_count); + let mut stack = ast.arena.descendant_stack(node_index)?; + while let Some(child) = stack.pop() { + descendants.push(native_ast_child_handle(child)?); + if let NativeAstChild::Node(index) = child { + for child in ast.arena.node(index)?.children.iter().rev() { + stack.push(*child); + } + } + } + Ok(descendants) } -#[php_class] -#[php(name = "WP_MySQL_Native_Parser")] +fn native_ast_descendant_id_rows(arena: &NativeAstArena, node_index: usize) -> PhpResult> { + let node = arena.node(node_index)?; + let mut rows = Vec::with_capacity(node.descendant_count.saturating_mul(2)); + let mut stack = arena.descendant_stack(node_index)?; + while let Some(child) = stack.pop() { + match child { + NativeAstChild::Node(index) => { + let node = arena.node(index)?; + rows.push(0); + rows.push(node.rule_id); + for child in node.children.iter().rev() { + stack.push(*child); + } + } + NativeAstChild::Token(index) => { + rows.push(1); + rows.push(arena.token_source.token_info(index)?.id); + } + } + } + Ok(rows) +} + +fn native_ast_descendant_packed_id_rows( + arena: &NativeAstArena, + node_index: usize, +) -> PhpResult> { + let node = arena.node(node_index)?; + let mut rows = Vec::with_capacity(node.descendant_count); + let mut stack = arena.descendant_stack(node_index)?; + while let Some(child) = stack.pop() { + match child { + NativeAstChild::Node(index) => { + let node = arena.node(index)?; + rows.push(native_ast_pack_kind_id(0, node.rule_id)); + for child in node.children.iter().rev() { + stack.push(*child); + } + } + NativeAstChild::Token(index) => { + rows.push(native_ast_pack_kind_id( + 1, + arena.token_source.token_info(index)?.id, + )); + } + } + } + Ok(rows) +} + +fn native_ast_descendant_scalar_rows( + arena: &NativeAstArena, + node_index: usize, +) -> PhpResult> { + let node = arena.node(node_index)?; + let mut rows = Vec::with_capacity(node.descendant_count.saturating_mul(4)); + let mut stack = arena.descendant_stack(node_index)?; + while let Some(child) = stack.pop() { + match child { + NativeAstChild::Node(index) => { + let node = arena.node(index)?; + rows.push(0); + rows.push(node.rule_id); + // Keep the PHP and native benchmark rows directly comparable: + // PHP parser nodes don't store spans, so node rows carry no + // span data. Token rows below carry public token start/length. + rows.push(-1); + rows.push(0); + for child in node.children.iter().rev() { + stack.push(*child); + } + } + NativeAstChild::Token(index) => { + let token = arena.token_source.token_info(index)?; + rows.push(1); + rows.push(token.id); + rows.push(token.start as i64); + rows.push(token.end.saturating_sub(token.start) as i64); + } + } + } + Ok(rows) +} + +fn native_ast_descendant_packed_scalar_rows( + arena: &NativeAstArena, + node_index: usize, +) -> PhpResult> { + let node = arena.node(node_index)?; + let mut rows = Vec::with_capacity(node.descendant_count.saturating_mul(2)); + let mut stack = arena.descendant_stack(node_index)?; + while let Some(child) = stack.pop() { + match child { + NativeAstChild::Node(index) => { + let node = arena.node(index)?; + rows.push(native_ast_pack_kind_id(0, node.rule_id)); + rows.push(-1); + for child in node.children.iter().rev() { + stack.push(*child); + } + } + NativeAstChild::Token(index) => { + let token = arena.token_source.token_info(index)?; + rows.push(native_ast_pack_kind_id(1, token.id)); + rows.push(native_ast_pack_span( + token.start, + token.end.saturating_sub(token.start), + )); + } + } + } + Ok(rows) +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_descendant_id_rows( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult> { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + native_ast_descendant_id_rows(&ast.arena, native_ast_node_index_from_handle(handle)?) +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_descendant_packed_id_rows( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult> { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + native_ast_descendant_packed_id_rows(&ast.arena, native_ast_node_index_from_handle(handle)?) +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_descendant_scalar_rows( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult> { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + native_ast_descendant_scalar_rows(&ast.arena, native_ast_node_index_from_handle(handle)?) +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_descendant_packed_scalar_rows( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult> { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + native_ast_descendant_packed_scalar_rows(&ast.arena, native_ast_node_index_from_handle(handle)?) +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_handle_kind( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + match native_ast_child_from_handle(handle)? { + NativeAstChild::Node(index) => { + ast.arena.node(index)?; + Ok(0) + } + NativeAstChild::Token(index) => { + ast.arena.token_source.token_info(index)?; + Ok(1) + } + } +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_native_handle_id( + wrapper_zval: &Zval, + handle: i64, +) -> PhpResult { + let (ast, _node_index) = native_ast_from_wrapper(wrapper_zval)?; + match native_ast_child_from_handle(handle)? { + NativeAstChild::Node(index) => Ok(ast.arena.node(index)?.rule_id), + NativeAstChild::Token(index) => Ok(ast.arena.token_source.token_info(index)?.id), + } +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_start(wrapper_zval: &Zval) -> PhpResult { + let (ast, node_index) = native_ast_from_wrapper(wrapper_zval)?; + let node = ast.arena.node(node_index)?; + let token_index = node + .first_token + .ok_or_else(|| php_error("Native AST node has no descendant tokens"))?; + let token = ast.arena.token_source.token_info(token_index)?; + i64::try_from(token.start).map_err(php_error) +} + +#[php_function] +pub fn wp_sqlite_mysql_native_ast_get_length(wrapper_zval: &Zval) -> PhpResult { + let (ast, node_index) = native_ast_from_wrapper(wrapper_zval)?; + let node = ast.arena.node(node_index)?; + let first_token_index = node + .first_token + .ok_or_else(|| php_error("Native AST node has no descendant tokens"))?; + let last_token_index = node + .last_token + .ok_or_else(|| php_error("Native AST node has no descendant tokens"))?; + let first_token = ast.arena.token_source.token_info(first_token_index)?; + let last_token = ast.arena.token_source.token_info(last_token_index)?; + let length = last_token.end.saturating_sub(first_token.start); + i64::try_from(length).map_err(php_error) +} + +#[php_class] +#[php(name = "WP_MySQL_Native_Parser")] pub struct WpMySqlNativeParser { grammar: Arc, token_source: Arc, @@ -1724,6 +2422,108 @@ impl WpMySqlNativeParser { }) } + pub fn parse_native_descendant_id_rows(&mut self) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_native_descendant_rows(NativeAstRowFormat::Id) + }) + } + + pub fn parse_native_descendant_packed_id_rows(&mut self) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_native_descendant_rows(NativeAstRowFormat::PackedId) + }) + } + + pub fn parse_native_descendant_scalar_rows(&mut self) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_native_descendant_rows(NativeAstRowFormat::Scalar) + }) + } + + pub fn parse_native_descendant_packed_scalar_rows(&mut self) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_native_descendant_rows(NativeAstRowFormat::PackedScalar) + }) + } + + pub fn parse_native_descendant_packed_id_stats(&mut self) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_native_descendant_stats(NativeAstStatsFormat::PackedId) + }) + } + + pub fn parse_native_descendant_packed_scalar_stats( + &mut self, + consume_token_bytes: Option, + ) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_native_descendant_stats(NativeAstStatsFormat::PackedScalar { + consume_token_bytes: consume_token_bytes.unwrap_or(false), + }) + }) + } + + pub fn parse_sql_native_descendant_packed_id_stats( + &mut self, + sql: &Zval, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_sql_native_packed_id_stats(sql, mysql_version, sql_modes) + }) + } + + pub fn parse_sql_native_descendant_packed_scalar_stats( + &mut self, + sql: &Zval, + consume_token_bytes: Option, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult>> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.reset_sql(sql, mysql_version, sql_modes)?; + self.parse_native_descendant_stats(NativeAstStatsFormat::PackedScalar { + consume_token_bytes: consume_token_bytes.unwrap_or(false), + }) + }) + } + + pub fn parse_sql_batch_native_descendant_packed_id_stats( + &mut self, + queries: &Zval, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_sql_batch_native_descendant_stats( + queries, + NativeAstStatsFormat::PackedId, + mysql_version, + sql_modes, + ) + }) + } + + pub fn parse_sql_batch_native_descendant_packed_scalar_stats( + &mut self, + queries: &Zval, + consume_token_bytes: Option, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult> { + stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || { + self.parse_sql_batch_native_descendant_stats( + queries, + NativeAstStatsFormat::PackedScalar { + consume_token_bytes: consume_token_bytes.unwrap_or(false), + }, + mysql_version, + sql_modes, + ) + }) + } + pub fn next_query(&mut self) -> PhpResult { stacker::maybe_grow(STACK_RED_ZONE, STACK_GROW_SIZE, || self.next_query_inner()) } @@ -1760,6 +2560,10 @@ impl WpMySqlNativeParser { } fn parse_native_ast(&mut self) -> PhpResult> { + Ok(NativeAstState::new(Arc::new(self.parse_native_arena()?))) + } + + fn parse_native_arena(&mut self) -> PhpResult { let mut arena = NativeAstArena::new(Arc::clone(&self.grammar), Arc::clone(&self.token_source)); let query_rule_id = self.grammar.query_rule_id; @@ -1776,7 +2580,394 @@ impl WpMySqlNativeParser { } } }; - Ok(NativeAstState::new(Arc::new(arena))) + Ok(arena) + } + + fn parse_native_descendant_rows( + &mut self, + format: NativeAstRowFormat, + ) -> PhpResult>> { + let mut rows = NativeAstRows::with_token_capacity(self.token_ids.len(), format); + match self.parse_recursive_rows(self.grammar.query_rule_id, &mut rows, true)? { + NativeDirectParseMatch::No => Ok(None), + NativeDirectParseMatch::Empty | NativeDirectParseMatch::Match => { + Ok(Some(rows.into_vec())) + } + } + } + + fn parse_native_descendant_stats( + &mut self, + format: NativeAstStatsFormat, + ) -> PhpResult>> { + Ok(self + .parse_native_descendant_stats_inner(format)? + .map(NativeAstStats::into_vec)) + } + + fn parse_native_descendant_stats_inner( + &mut self, + format: NativeAstStatsFormat, + ) -> PhpResult> { + if matches!(format, NativeAstStatsFormat::PackedId) { + return Ok(self.parse_packed_id_stats_for_token_ids(&self.token_ids)); + } + + let sql_bytes = match format { + NativeAstStatsFormat::PackedScalar { + consume_token_bytes: true, + } => self.token_source.sql_bytes(), + _ => None, + }; + let mut stats = NativeAstStats::new(format, sql_bytes); + match self.parse_recursive_stats(self.grammar.query_rule_id, &mut stats, true)? { + NativeDirectParseMatch::No => Ok(None), + NativeDirectParseMatch::Empty | NativeDirectParseMatch::Match => Ok(Some(stats)), + } + } + + fn reset_sql( + &mut self, + sql: &Zval, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult<()> { + let sql_modes = sql_modes + .as_ref() + .map(|modes| sql_modes_mask(modes)) + .unwrap_or(0); + self.reset_sql_with_modes_mask(sql, mysql_version, sql_modes) + } + + fn reset_sql_with_modes_mask( + &mut self, + sql: &Zval, + mysql_version: Option, + sql_modes: i64, + ) -> PhpResult<()> { + let lexer = + WpMySqlNativeLexer::from_raw_sql_zval_with_modes_mask(sql, mysql_version, sql_modes)?; + let (token_source, token_ids) = lexer.into_raw_token_source(); + self.token_ids = token_ids; + self.token_source = Arc::new(token_source); + self.position = 0; + self.current_ast = None; + self.current_php_ast = None; + Ok(()) + } + + fn parse_sql_native_packed_id_stats( + &self, + sql: &Zval, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult>> { + let sql_modes = sql_modes + .as_ref() + .map(|modes| sql_modes_mask(modes)) + .unwrap_or(0); + let lexer = + WpMySqlNativeLexer::from_raw_sql_zval_with_modes_mask(sql, mysql_version, sql_modes)?; + Ok(self + .parse_packed_id_stats_for_token_ids(&lexer.into_token_ids()) + .map(NativeAstStats::into_vec)) + } + + fn parse_sql_batch_native_descendant_stats( + &mut self, + queries: &Zval, + format: NativeAstStatsFormat, + mysql_version: Option, + sql_modes: Option>, + ) -> PhpResult> { + let queries = queries + .array() + .ok_or_else(|| php_error("Parser batch queries must be an array"))?; + let mut processed = 0; + let mut failures = 0; + let mut descendants = 0; + let mut checksum = 0; + let sql_modes = sql_modes + .as_ref() + .map(|modes| sql_modes_mask(modes)) + .unwrap_or(0); + + for (_, query) in queries { + processed += 1; + match format { + NativeAstStatsFormat::PackedId => { + let lexer = WpMySqlNativeLexer::from_raw_sql_zval_with_modes_mask( + query, + mysql_version, + sql_modes, + )?; + match self.parse_packed_id_stats_for_token_ids(&lexer.into_token_ids()) { + Some(stats) => { + descendants += stats.descendants; + checksum += stats.checksum; + } + None => { + failures += 1; + } + } + } + NativeAstStatsFormat::PackedScalar { .. } => { + self.reset_sql_with_modes_mask(query, mysql_version, sql_modes)?; + match self.parse_native_descendant_stats_inner(format)? { + Some(stats) => { + descendants += stats.descendants; + checksum += stats.checksum; + } + None => { + failures += 1; + } + } + } + } + } + + Ok(vec![processed, failures, descendants, checksum]) + } + + fn parse_packed_id_stats_for_token_ids(&self, token_ids: &[i64]) -> Option { + if self.grammar.highest_terminal_id == compiled_packed_id_parser::HIGHEST_TERMINAL_ID + && self.grammar.query_rule_id == compiled_packed_id_parser::QUERY_RULE_ID + && self.grammar.select_statement_rule_id + == Some(compiled_packed_id_parser::SELECT_STATEMENT_RULE_ID) + { + return compiled_packed_id_parser::CompiledPackedIdStatsParser::new(token_ids) + .parse() + .map(|(descendants, checksum)| NativeAstStats { + descendants, + checksum, + format: NativeAstStatsFormat::PackedId, + sql_bytes: None, + }); + } + + let mut stats = NativeAstStats::new(NativeAstStatsFormat::PackedId, None); + let mut position = 0; + match parse_recursive_packed_id_stats( + &self.grammar, + token_ids, + &mut position, + self.grammar.query_rule_id, + &mut stats, + true, + ) { + NativeDirectParseMatch::No => None, + NativeDirectParseMatch::Empty | NativeDirectParseMatch::Match => Some(stats), + } + } + + fn parse_recursive_rows( + &mut self, + rule_id: i64, + rows: &mut NativeAstRows, + skip_current_node: bool, + ) -> PhpResult { + if rule_id <= self.grammar.highest_terminal_id { + if self.position >= self.token_ids.len() { + return Ok(NativeDirectParseMatch::No); + } + if rule_id == 0 { + return Ok(NativeDirectParseMatch::Empty); + } + if self.token_ids[self.position] == rule_id { + let token_index = self.position; + self.position += 1; + match rows.format { + NativeAstRowFormat::Id | NativeAstRowFormat::PackedId => { + rows.push_token_id(rule_id); + } + NativeAstRowFormat::Scalar | NativeAstRowFormat::PackedScalar => { + rows.push_token(self.token_source.token_info(token_index)?); + } + } + return Ok(NativeDirectParseMatch::Match); + } + return Ok(NativeDirectParseMatch::No); + } + + let grammar = unsafe { + // The parser owns an Arc to immutable grammar data for its full lifetime. + // Taking a raw shared reference avoids cloning hot branches just to satisfy + // the borrow checker while recursive parsing mutates only `position`. + &*Arc::as_ptr(&self.grammar) + }; + + let Some(rule) = grammar.rule(rule_id) else { + return Ok(NativeDirectParseMatch::No); + }; + if rule.branches.is_empty() { + return Ok(NativeDirectParseMatch::No); + } + + if let Some(first_set) = rule.first_set.as_ref() { + let token_id = self.token_ids.get(self.position).copied().unwrap_or(0); + if !first_set.contains(token_id) && !rule.nullable { + return Ok(NativeDirectParseMatch::No); + } + } else if !rule.nullable { + return Ok(NativeDirectParseMatch::No); + } + + let starting_position = self.position; + let starting_row_count = rows.len(); + + for branch in &rule.branches { + self.position = starting_position; + rows.truncate(starting_row_count); + let emit_node = !skip_current_node && !rule.is_fragment; + if emit_node { + rows.push_node(rule_id); + } + let mut branch_matches = true; + let mut has_children = false; + + for &subrule_id in branch { + let child_starting_row_count = rows.len(); + match self.parse_recursive_rows(subrule_id, rows, false)? { + NativeDirectParseMatch::No => { + branch_matches = false; + break; + } + NativeDirectParseMatch::Empty => {} + NativeDirectParseMatch::Match => { + if rows.len() != child_starting_row_count { + has_children = true; + } + } + } + } + + if branch_matches + && grammar.select_statement_rule_id == Some(rule_id) + && self + .token_ids + .get(self.position) + .is_some_and(|token_id| *token_id == lex::INTO_SYMBOL) + { + branch_matches = false; + } + + if branch_matches { + if has_children { + return Ok(NativeDirectParseMatch::Match); + } + rows.truncate(starting_row_count); + return Ok(NativeDirectParseMatch::Empty); + } + } + + self.position = starting_position; + rows.truncate(starting_row_count); + Ok(NativeDirectParseMatch::No) + } + + fn parse_recursive_stats( + &mut self, + rule_id: i64, + stats: &mut NativeAstStats, + skip_current_node: bool, + ) -> PhpResult { + if rule_id <= self.grammar.highest_terminal_id { + if self.position >= self.token_ids.len() { + return Ok(NativeDirectParseMatch::No); + } + if rule_id == 0 { + return Ok(NativeDirectParseMatch::Empty); + } + if self.token_ids[self.position] == rule_id { + let token_index = self.position; + self.position += 1; + match stats.format { + NativeAstStatsFormat::PackedId => { + stats.push_token_id(rule_id); + } + NativeAstStatsFormat::PackedScalar { .. } => { + stats.push_token(self.token_source.token_info(token_index)?); + } + } + return Ok(NativeDirectParseMatch::Match); + } + return Ok(NativeDirectParseMatch::No); + } + + let grammar = unsafe { + // The parser owns an Arc to immutable grammar data for its full lifetime. + // Taking a raw shared reference avoids cloning hot branches just to satisfy + // the borrow checker while recursive parsing mutates only `position`. + &*Arc::as_ptr(&self.grammar) + }; + + let Some(rule) = grammar.rule(rule_id) else { + return Ok(NativeDirectParseMatch::No); + }; + if rule.branches.is_empty() { + return Ok(NativeDirectParseMatch::No); + } + + if let Some(first_set) = rule.first_set.as_ref() { + let token_id = self.token_ids.get(self.position).copied().unwrap_or(0); + if !first_set.contains(token_id) && !rule.nullable { + return Ok(NativeDirectParseMatch::No); + } + } else if !rule.nullable { + return Ok(NativeDirectParseMatch::No); + } + + let starting_position = self.position; + let starting_stats = stats.state(); + + for branch in &rule.branches { + self.position = starting_position; + stats.restore(starting_stats); + let emit_node = !skip_current_node && !rule.is_fragment; + if emit_node { + stats.push_node(rule_id); + } + let mut branch_matches = true; + let mut has_children = false; + + for &subrule_id in branch { + let child_starting_descendants = stats.descendants; + match self.parse_recursive_stats(subrule_id, stats, false)? { + NativeDirectParseMatch::No => { + branch_matches = false; + break; + } + NativeDirectParseMatch::Empty => {} + NativeDirectParseMatch::Match => { + if stats.descendants != child_starting_descendants { + has_children = true; + } + } + } + } + + if branch_matches + && grammar.select_statement_rule_id == Some(rule_id) + && self + .token_ids + .get(self.position) + .is_some_and(|token_id| *token_id == lex::INTO_SYMBOL) + { + branch_matches = false; + } + + if branch_matches { + if has_children { + return Ok(NativeDirectParseMatch::Match); + } + stats.restore(starting_stats); + return Ok(NativeDirectParseMatch::Empty); + } + } + + self.position = starting_position; + stats.restore(starting_stats); + Ok(NativeDirectParseMatch::No) } fn parse_recursive_inner( @@ -2145,6 +3336,9 @@ pub fn get_module(module: ModuleBuilder) -> ModuleBuilder { .class::() .class::() .class::() + .class::() + .class::() + .class::() .function(wrap_function!(wp_sqlite_mysql_native_ast_release_wrapper)) .function(wrap_function!( wp_sqlite_mysql_native_ast_materialize_wrapper @@ -2175,6 +3369,31 @@ pub fn get_module(module: ModuleBuilder) -> ModuleBuilder { .function(wrap_function!( wp_sqlite_mysql_native_ast_get_descendant_tokens )) + .function(wrap_function!(wp_sqlite_mysql_native_ast_get_native_handle)) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_child_handles + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_descendant_handles + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_descendant_id_rows + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_descendant_packed_id_rows + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_descendant_scalar_rows + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_descendant_packed_scalar_rows + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_handle_kind + )) + .function(wrap_function!( + wp_sqlite_mysql_native_ast_get_native_handle_id + )) .function(wrap_function!(wp_sqlite_mysql_native_ast_get_start)) .function(wrap_function!(wp_sqlite_mysql_native_ast_get_length)) .info_function(php_module_info) diff --git a/packages/php-ext-wp-mysql-parser/src/native_sqlite_connection.rs b/packages/php-ext-wp-mysql-parser/src/native_sqlite_connection.rs new file mode 100644 index 000000000..a08bd633f --- /dev/null +++ b/packages/php-ext-wp-mysql-parser/src/native_sqlite_connection.rs @@ -0,0 +1,676 @@ +use std::rc::Rc; +use std::time::Duration; + +use ext_php_rs::convert::IntoZval; +use ext_php_rs::exception::PhpResult; +use ext_php_rs::prelude::*; +use ext_php_rs::types::{ZendHashTable, ZendObject, Zval}; +use rusqlite::types::ValueRef; + +use crate::{native_sqlite_translator, php_error, BinaryString}; + +const FETCH_DEFAULT: i64 = 0; +const FETCH_ASSOC: i64 = 2; +const FETCH_NUM: i64 = 3; +const FETCH_BOTH: i64 = 4; +const FETCH_OBJ: i64 = 5; +const FETCH_COLUMN: i64 = 7; +const FETCH_NAMED: i64 = 11; + +#[derive(Clone)] +enum NativeSqliteValue { + Null, + Bytes(Vec), +} + +impl NativeSqliteValue { + fn from_value_ref(value: ValueRef<'_>) -> Self { + match value { + ValueRef::Null => Self::Null, + ValueRef::Integer(value) => Self::Bytes(value.to_string().into_bytes()), + ValueRef::Real(value) => Self::Bytes(value.to_string().into_bytes()), + ValueRef::Text(value) | ValueRef::Blob(value) => Self::Bytes(value.to_vec()), + } + } + + fn to_zval(&self) -> PhpResult { + match self { + Self::Null => Ok(Zval::null()), + Self::Bytes(value) => BinaryString(value.clone()) + .into_zval(false) + .map_err(php_error), + } + } +} + +#[php_class] +#[php(name = "WP_SQLite_Native_Connection")] +pub struct WpSqliteNativeConnection { + connection: Rc, +} + +#[php_impl] +impl WpSqliteNativeConnection { + pub fn __construct(path: String) -> PhpResult { + let connection = rusqlite::Connection::open(path).map_err(php_error)?; + connection + .busy_timeout(Duration::from_secs(10)) + .map_err(php_error)?; + connection + .execute_batch("PRAGMA foreign_keys = ON") + .map_err(php_error)?; + Ok(Self { + connection: Rc::new(connection), + }) + } + + pub fn query(&self, sql: String) -> PhpResult { + let sqlite_queries = vec![sql.clone()]; + let statement = self.prepare_query_statement(sql, -1, sqlite_queries)?; + Ok(statement) + } + + pub fn query_mysql(&self, sql: String) -> PhpResult> { + match native_sqlite_translator::translate_sqlite_plan_code(sql.as_bytes()) { + native_sqlite_translator::PLAN_SELECT_ORIGINAL + | native_sqlite_translator::PLAN_SELECT_FOUND_ROWS_CODE => return Ok(None), + native_sqlite_translator::PLAN_UPDATE_ORIGINAL => { + return Ok(Some(self.prepare_execute_statement(sql)?)); + } + _ => { + if !native_sqlite_translator::contains_sql_calc_found_rows(&sql) { + return Ok(None); + } + } + } + + let Some(plan) = native_sqlite_translator::translate_sqlite_plan(sql.as_bytes()) else { + return Ok(None); + }; + + match plan.first().map(String::as_str) { + Some(native_sqlite_translator::SELECT_PASSTHROUGH) => { + let Some(sqlite_query) = plan.get(1) else { + return Ok(None); + }; + let Some(count_source_query) = plan.get(2).filter(|query| !query.is_empty()) else { + return Ok(None); + }; + + let count_query = format!("SELECT COUNT(*) AS cnt FROM ({count_source_query})"); + let found_rows = self + .connection + .query_row(&count_query, [], |row| row.get::<_, i64>(0)) + .map_err(php_error)?; + let statement = self.execute_query_statement( + sqlite_query.clone(), + found_rows, + vec![count_query, sqlite_query.clone()], + )?; + Ok(Some(statement)) + } + + Some(native_sqlite_translator::UPDATE_PASSTHROUGH) => { + let Some(sqlite_query) = plan.get(1) else { + return Ok(None); + }; + Ok(Some(self.prepare_execute_statement(sqlite_query.clone())?)) + } + + _ => Ok(None), + } + } + + pub fn query_mysql_packed_rows( + &self, + sql: String, + ) -> PhpResult> { + match native_sqlite_translator::translate_sqlite_plan_code(sql.as_bytes()) { + native_sqlite_translator::PLAN_SELECT_ORIGINAL => { + return self + .execute_packed_query_statement(sql.clone(), -1, vec![sql]) + .map(Some); + } + native_sqlite_translator::PLAN_SELECT_FOUND_ROWS_CODE + | native_sqlite_translator::PLAN_UPDATE_ORIGINAL => return Ok(None), + _ => { + if !native_sqlite_translator::contains_sql_calc_found_rows(&sql) { + return Ok(None); + } + } + } + + let Some(plan) = native_sqlite_translator::translate_sqlite_plan(sql.as_bytes()) else { + return Ok(None); + }; + + let Some(native_sqlite_translator::SELECT_PASSTHROUGH) = plan.first().map(String::as_str) + else { + return Ok(None); + }; + let Some(sqlite_query) = plan.get(1) else { + return Ok(None); + }; + let Some(count_source_query) = plan.get(2).filter(|query| !query.is_empty()) else { + return Ok(None); + }; + + let count_query = format!("SELECT COUNT(*) AS cnt FROM ({count_source_query})"); + let found_rows = self + .connection + .query_row(&count_query, [], |row| row.get::<_, i64>(0)) + .map_err(php_error)?; + self.execute_packed_query_statement( + sqlite_query.clone(), + found_rows, + vec![count_query, sqlite_query.clone()], + ) + .map(Some) + } + + pub fn execute(&self, sql: String) -> PhpResult { + let affected_rows = self.connection.execute(&sql, []).map_err(php_error)?; + i64::try_from(affected_rows).map_err(php_error) + } + + pub fn execute_statement(&self, sql: String) -> PhpResult { + self.prepare_execute_statement(sql) + } +} + +impl WpSqliteNativeConnection { + fn prepare_query_statement( + &self, + sql: String, + found_rows: i64, + sqlite_queries: Vec, + ) -> PhpResult { + let statement = self.connection.prepare(&sql).map_err(php_error)?; + let columns = statement + .column_names() + .iter() + .map(ToString::to_string) + .collect::>(); + drop(statement); + + Ok(WpSqliteNativeStatement { + connection: Some(Rc::clone(&self.connection)), + sql: Some(sql), + columns, + rows: Vec::new(), + cursor: 0, + loaded: false, + exhausted: false, + default_fetch_mode: FETCH_BOTH, + affected_rows: 0, + found_rows, + sqlite_queries, + }) + } + + fn execute_query_statement( + &self, + sql: String, + found_rows: i64, + sqlite_queries: Vec, + ) -> PhpResult { + let mut statement = self.connection.prepare(&sql).map_err(php_error)?; + let columns = statement + .column_names() + .iter() + .map(ToString::to_string) + .collect::>(); + let column_count = columns.len(); + let mut result_rows = Vec::new(); + let mut rows = statement.query([]).map_err(php_error)?; + while let Some(row) = rows.next().map_err(php_error)? { + let mut values = Vec::with_capacity(column_count); + for index in 0..column_count { + values.push(NativeSqliteValue::from_value_ref( + row.get_ref(index).map_err(php_error)?, + )); + } + result_rows.push(values); + } + + Ok(WpSqliteNativeStatement { + connection: None, + sql: None, + columns, + rows: result_rows, + cursor: 0, + loaded: true, + exhausted: false, + default_fetch_mode: FETCH_BOTH, + affected_rows: 0, + found_rows, + sqlite_queries, + }) + } + + fn execute_packed_query_statement( + &self, + sql: String, + found_rows: i64, + sqlite_queries: Vec, + ) -> PhpResult { + let mut statement = self.connection.prepare(&sql).map_err(php_error)?; + let columns = statement + .column_names() + .iter() + .map(ToString::to_string) + .collect::>(); + let column_count = columns.len(); + let mut packed_rows = Vec::new(); + let mut checksum = 0i64; + let mut row_count = 0i64; + let mut rows = statement.query([]).map_err(php_error)?; + while let Some(row) = rows.next().map_err(php_error)? { + row_count += 1; + for index in 0..column_count { + append_packed_sqlite_value( + row.get_ref(index).map_err(php_error)?, + &mut packed_rows, + &mut checksum, + ); + } + } + + checksum += found_rows + row_count + i64::try_from(column_count).map_err(php_error)?; + Ok(WpSqliteNativePackedResult { + columns, + rows: packed_rows, + row_count, + found_rows, + checksum, + sqlite_queries, + }) + } + + fn prepare_execute_statement(&self, sql: String) -> PhpResult { + let affected_rows = self.execute(sql.clone())?; + Ok(WpSqliteNativeStatement { + connection: None, + sql: None, + columns: Vec::new(), + rows: Vec::new(), + cursor: 0, + loaded: true, + exhausted: true, + default_fetch_mode: FETCH_BOTH, + affected_rows, + found_rows: -1, + sqlite_queries: vec![sql], + }) + } +} + +#[php_class] +#[php(name = "WP_SQLite_Native_Packed_Result")] +pub struct WpSqliteNativePackedResult { + columns: Vec, + rows: Vec, + row_count: i64, + found_rows: i64, + checksum: i64, + sqlite_queries: Vec, +} + +#[php_impl] +impl WpSqliteNativePackedResult { + pub fn column_count(&self) -> usize { + self.columns.len() + } + + pub fn columns(&self) -> Vec { + self.columns.clone() + } + + pub fn row_count(&self) -> i64 { + self.row_count + } + + pub fn found_rows(&self) -> i64 { + self.found_rows + } + + pub fn checksum(&self) -> i64 { + self.checksum + } + + pub fn packed_rows(&self) -> PhpResult { + BinaryString(self.rows.clone()) + .into_zval(false) + .map_err(php_error) + } + + pub fn take_packed_rows(&mut self) -> PhpResult { + BinaryString(std::mem::take(&mut self.rows)) + .into_zval(false) + .map_err(php_error) + } + + pub fn sqlite_queries(&self) -> Vec { + self.sqlite_queries.clone() + } +} + +#[php_class] +#[php(name = "WP_SQLite_Native_Statement")] +pub struct WpSqliteNativeStatement { + connection: Option>, + sql: Option, + columns: Vec, + rows: Vec>, + cursor: usize, + loaded: bool, + exhausted: bool, + default_fetch_mode: i64, + affected_rows: i64, + found_rows: i64, + sqlite_queries: Vec, +} + +#[php_impl] +impl WpSqliteNativeStatement { + pub fn column_count(&self) -> usize { + self.columns.len() + } + + pub fn row_count(&self) -> i64 { + self.affected_rows + } + + pub fn result_row_count(&self) -> usize { + self.rows.len() + } + + pub fn found_rows(&self) -> i64 { + self.found_rows + } + + pub fn sqlite_queries(&self) -> Vec { + self.sqlite_queries.clone() + } + + #[php(defaults(mode = Some(0), cursor_orientation = Some(0), cursor_offset = Some(0)))] + pub fn fetch( + &mut self, + mode: Option, + _cursor_orientation: Option, + _cursor_offset: Option, + ) -> PhpResult { + self.load_rows()?; + if self.exhausted || self.cursor >= self.rows.len() { + return false.into_zval(false).map_err(php_error); + } + + let mode = self.resolve_fetch_mode(mode.unwrap_or(FETCH_DEFAULT)); + let row = self.row_to_zval(&self.rows[self.cursor], mode, 0)?; + self.cursor += 1; + Ok(row) + } + + #[php(defaults(column = Some(0)))] + pub fn fetch_column(&mut self, column: Option) -> PhpResult { + self.load_rows()?; + if self.exhausted || self.cursor >= self.rows.len() { + return false.into_zval(false).map_err(php_error); + } + + let value = self.rows[self.cursor] + .get(usize::try_from(column.unwrap_or(0)).unwrap_or(usize::MAX)) + .map(NativeSqliteValue::to_zval) + .unwrap_or_else(|| false.into_zval(false).map_err(php_error))?; + self.cursor += 1; + Ok(value) + } + + #[php(defaults(mode = Some(0), column = None, _constructor_args = None))] + pub fn fetch_all( + &mut self, + mode: Option, + column: Option<&Zval>, + _constructor_args: Option<&Zval>, + ) -> PhpResult { + let mode = self.resolve_fetch_mode(mode.unwrap_or(FETCH_DEFAULT)); + let column = column.and_then(Zval::long).unwrap_or(0); + let column = usize::try_from(column).unwrap_or(usize::MAX); + if !self.loaded && 0 == self.cursor { + return self.fetch_all_from_sql(mode, column); + } + + self.load_rows()?; + let mut result = ZendHashTable::with_capacity( + self.rows + .len() + .saturating_sub(self.cursor) + .try_into() + .unwrap_or(0), + ); + while self.cursor < self.rows.len() { + let row = if mode == FETCH_COLUMN { + self.rows[self.cursor] + .get(column) + .map(NativeSqliteValue::to_zval) + .unwrap_or_else(|| false.into_zval(false).map_err(php_error))? + } else { + self.row_to_zval(&self.rows[self.cursor], mode, 0)? + }; + result.push(row).map_err(php_error)?; + self.cursor += 1; + } + self.exhausted = true; + result.into_zval(false).map_err(php_error) + } + + pub fn fetch_object( + &mut self, + _class: Option, + _constructor_args: Option<&ZendHashTable>, + ) -> PhpResult { + self.fetch(Some(FETCH_OBJ), Some(0), Some(0)) + } + + pub fn get_column_meta(&self, column: i64) -> PhpResult { + let Some(name) = self + .columns + .get(usize::try_from(column).unwrap_or(usize::MAX)) + else { + return false.into_zval(false).map_err(php_error); + }; + + let mut meta = ZendHashTable::with_capacity(7); + meta.insert("native_type", "string").map_err(php_error)?; + meta.insert("pdo_type", 2i64).map_err(php_error)?; + meta.insert("flags", ZendHashTable::new()) + .map_err(php_error)?; + meta.insert("table", "").map_err(php_error)?; + meta.insert("name", name.as_str()).map_err(php_error)?; + meta.insert("len", -1i64).map_err(php_error)?; + meta.insert("precision", 0i64).map_err(php_error)?; + meta.into_zval(false).map_err(php_error) + } + + #[php(defaults(mode = 0))] + pub fn set_fetch_mode(&mut self, mode: i64) -> bool { + self.default_fetch_mode = mode; + true + } +} + +fn append_packed_sqlite_value(value: ValueRef<'_>, output: &mut Vec, checksum: &mut i64) { + match value { + ValueRef::Null => append_packed_bytes(None, output, checksum), + ValueRef::Integer(value) => { + let mut buffer = itoa::Buffer::new(); + append_packed_bytes(Some(buffer.format(value).as_bytes()), output, checksum) + } + ValueRef::Real(value) => { + append_packed_bytes(Some(value.to_string().as_bytes()), output, checksum) + } + ValueRef::Text(value) | ValueRef::Blob(value) => { + append_packed_bytes(Some(value), output, checksum) + } + } +} + +fn append_packed_bytes(value: Option<&[u8]>, output: &mut Vec, checksum: &mut i64) { + let length = value + .map(|bytes| u32::try_from(bytes.len()).unwrap_or(u32::MAX - 1)) + .unwrap_or(u32::MAX); + for byte in length.to_le_bytes() { + output.push(byte); + *checksum += i64::from(byte); + } + if let Some(bytes) = value { + output.extend_from_slice(bytes); + for byte in bytes { + *checksum += i64::from(*byte); + } + } +} + +impl WpSqliteNativeStatement { + fn load_rows(&mut self) -> PhpResult<()> { + if self.loaded { + return Ok(()); + } + + let Some(connection) = self.connection.as_ref() else { + self.loaded = true; + return Ok(()); + }; + let Some(sql) = self.sql.as_ref() else { + self.loaded = true; + return Ok(()); + }; + + let mut statement = connection.prepare(sql).map_err(php_error)?; + let column_count = self.columns.len(); + let mut rows = statement.query([]).map_err(php_error)?; + while let Some(row) = rows.next().map_err(php_error)? { + let mut values = Vec::with_capacity(column_count); + for index in 0..column_count { + values.push(NativeSqliteValue::from_value_ref( + row.get_ref(index).map_err(php_error)?, + )); + } + self.rows.push(values); + } + self.loaded = true; + Ok(()) + } + + fn fetch_all_from_sql(&mut self, mode: i64, column: usize) -> PhpResult { + let Some(connection) = self.connection.as_ref() else { + self.loaded = true; + self.exhausted = true; + return ZendHashTable::new().into_zval(false).map_err(php_error); + }; + let Some(sql) = self.sql.as_ref() else { + self.loaded = true; + self.exhausted = true; + return ZendHashTable::new().into_zval(false).map_err(php_error); + }; + + let mut statement = connection.prepare(sql).map_err(php_error)?; + let column_count = self.columns.len(); + let mut rows = statement.query([]).map_err(php_error)?; + let mut result = ZendHashTable::new(); + while let Some(row) = rows.next().map_err(php_error)? { + let mut values = Vec::with_capacity(column_count); + for index in 0..column_count { + values.push(NativeSqliteValue::from_value_ref( + row.get_ref(index).map_err(php_error)?, + )); + } + let row = if mode == FETCH_COLUMN { + values + .get(column) + .map(NativeSqliteValue::to_zval) + .unwrap_or_else(|| false.into_zval(false).map_err(php_error))? + } else { + self.row_to_zval(&values, mode, 0)? + }; + result.push(row).map_err(php_error)?; + } + + self.loaded = true; + self.exhausted = true; + result.into_zval(false).map_err(php_error) + } + + fn resolve_fetch_mode(&self, mode: i64) -> i64 { + if mode == FETCH_DEFAULT { + self.default_fetch_mode + } else { + mode + } + } + + fn row_to_zval(&self, row: &[NativeSqliteValue], mode: i64, column: usize) -> PhpResult { + match mode { + FETCH_ASSOC => self.row_to_assoc(row, false), + FETCH_NUM => self.row_to_num(row), + FETCH_OBJ => self.row_to_object(row), + FETCH_COLUMN => row + .get(column) + .map(NativeSqliteValue::to_zval) + .unwrap_or_else(|| false.into_zval(false).map_err(php_error)), + FETCH_NAMED => self.row_to_assoc(row, true), + _ => self.row_to_both(row), + } + } + + fn row_to_num(&self, row: &[NativeSqliteValue]) -> PhpResult { + let mut array = ZendHashTable::with_capacity(row.len().try_into().unwrap_or(0)); + for value in row { + array.push(value.to_zval()?).map_err(php_error)?; + } + array.into_zval(false).map_err(php_error) + } + + fn row_to_assoc(&self, row: &[NativeSqliteValue], named_duplicates: bool) -> PhpResult { + let mut array = ZendHashTable::with_capacity(row.len().try_into().unwrap_or(0)); + for (index, value) in row.iter().enumerate() { + let name = &self.columns[index]; + if named_duplicates && array.get(name.as_str()).is_some() { + let mut values = ZendHashTable::new(); + values + .push(array.get(name.as_str()).unwrap().shallow_clone()) + .map_err(php_error)?; + values.push(value.to_zval()?).map_err(php_error)?; + array.insert(name.as_str(), values).map_err(php_error)?; + } else { + array + .insert(name.as_str(), value.to_zval()?) + .map_err(php_error)?; + } + } + array.into_zval(false).map_err(php_error) + } + + fn row_to_both(&self, row: &[NativeSqliteValue]) -> PhpResult { + let mut array = ZendHashTable::with_capacity((row.len() * 2).try_into().unwrap_or(0)); + for value in row { + array.push(value.to_zval()?).map_err(php_error)?; + } + for (index, value) in row.iter().enumerate() { + array + .insert(self.columns[index].as_str(), value.to_zval()?) + .map_err(php_error)?; + } + array.into_zval(false).map_err(php_error) + } + + fn row_to_object(&self, row: &[NativeSqliteValue]) -> PhpResult { + let mut object = ZendObject::new_stdclass(); + for (index, value) in row.iter().enumerate() { + object + .set_property(self.columns[index].as_str(), value.to_zval()?) + .map_err(php_error)?; + } + object.into_zval(false).map_err(php_error) + } +} diff --git a/packages/php-ext-wp-mysql-parser/src/native_sqlite_translator.rs b/packages/php-ext-wp-mysql-parser/src/native_sqlite_translator.rs new file mode 100644 index 000000000..51194a19d --- /dev/null +++ b/packages/php-ext-wp-mysql-parser/src/native_sqlite_translator.rs @@ -0,0 +1,593 @@ +pub(crate) const SELECT_PASSTHROUGH: &str = "select_passthrough"; +pub(crate) const UPDATE_PASSTHROUGH: &str = "update_passthrough"; +const SELECT_FOUND_ROWS: &str = "select_found_rows"; +const SELECT_SESSION_SQL_MODE: &str = "select_session_sql_mode"; +const SET_SESSION_SQL_MODE: &str = "set_session_sql_mode"; + +const PLAN_UNSUPPORTED: i64 = 0; +pub(crate) const PLAN_SELECT_ORIGINAL: i64 = 1; +pub(crate) const PLAN_UPDATE_ORIGINAL: i64 = 2; +pub(crate) const PLAN_SELECT_FOUND_ROWS_CODE: i64 = 3; + +const ALLOWED_TABLE_SUFFIXES: &[&str] = &[ + "actionscheduler_actions", + "actionscheduler_claims", + "actionscheduler_groups", + "actionscheduler_logs", + "blogmeta", + "blogs", + "commentmeta", + "comments", + "links", + "options", + "postmeta", + "posts", + "registration_log", + "signups", + "site", + "sitemeta", + "term_relationships", + "term_taxonomy", + "termmeta", + "terms", + "usermeta", + "users", + "wc_admin_note_actions", + "wc_admin_notes", + "wc_category_lookup", + "wc_customer_lookup", + "wc_download_log", + "wc_order_addresses", + "wc_order_coupon_lookup", + "wc_order_operational_data", + "wc_order_product_lookup", + "wc_order_stats", + "wc_order_tax_lookup", + "wc_orders", + "wc_orders_meta", + "wc_product_attributes_lookup", + "wc_product_download_directories", + "wc_product_meta_lookup", + "wc_rate_limits", + "wc_reserved_stock", + "wc_tax_rate_classes", + "wc_webhooks", + "woocommerce_api_keys", + "woocommerce_attribute_taxonomies", + "woocommerce_downloadable_product_permissions", + "woocommerce_log", + "woocommerce_order_itemmeta", + "woocommerce_order_items", + "woocommerce_payment_tokenmeta", + "woocommerce_payment_tokens", + "woocommerce_sessions", + "woocommerce_shipping_zone_locations", + "woocommerce_shipping_zone_methods", + "woocommerce_shipping_zones", + "woocommerce_tax_rate_locations", + "woocommerce_tax_rates", +]; + +pub fn translate_sqlite_plan(sql: &[u8]) -> Option> { + let sql = std::str::from_utf8(sql).ok()?; + let sql = trim_sql(sql); + if sql.is_empty() { + return None; + } + + if let Some(modes) = parse_set_session_sql_mode(sql) { + return Some(vec![SET_SESSION_SQL_MODE.to_string(), modes]); + } + + if let Some(alias) = parse_select_session_sql_mode(sql) { + return Some(vec![SELECT_SESSION_SQL_MODE.to_string(), alias]); + } + + if is_select_found_rows(sql) { + return Some(vec![SELECT_FOUND_ROWS.to_string()]); + } + + if is_fast_update_passthrough_candidate(sql) { + return Some(vec![UPDATE_PASSTHROUGH.to_string(), sql.to_string()]); + } + + if !is_fast_select_passthrough_candidate(sql) { + return None; + } + + let (sqlite_query, count_query) = strip_sql_calc_found_rows(sql); + Some(vec![ + SELECT_PASSTHROUGH.to_string(), + sqlite_query, + count_query.unwrap_or_default().to_string(), + ]) +} + +pub fn translate_sqlite_plan_code(sql: &[u8]) -> i64 { + let Ok(original_sql) = std::str::from_utf8(sql) else { + return PLAN_UNSUPPORTED; + }; + let sql = trim_sql(original_sql); + if sql.is_empty() { + return PLAN_UNSUPPORTED; + } + + if is_select_found_rows(sql) { + return PLAN_SELECT_FOUND_ROWS_CODE; + } + + if is_fast_update_passthrough_candidate(sql) { + if sql.len() != original_sql.len() { + return PLAN_UNSUPPORTED; + } + return PLAN_UPDATE_ORIGINAL; + } + + if !is_fast_select_passthrough_candidate(sql) { + return PLAN_UNSUPPORTED; + } + + if contains_sql_calc_found_rows(sql) { + return PLAN_UNSUPPORTED; + } + + if sql.len() != original_sql.len() { + return PLAN_UNSUPPORTED; + } + + PLAN_SELECT_ORIGINAL +} + +fn trim_sql(sql: &str) -> &str { + sql.trim().trim_end_matches(';').trim_end() +} + +fn parse_set_session_sql_mode(sql: &str) -> Option { + let mut rest = strip_keyword(sql, "set")?; + rest = rest.trim_start(); + rest = strip_keyword(rest, "session")?; + rest = rest.trim_start(); + rest = strip_keyword(rest, "sql_mode")?; + + let mut original_rest = rest.trim_start(); + original_rest = original_rest.strip_prefix('=')?; + original_rest = original_rest.trim_start(); + + let mut chars = original_rest.chars(); + let quote = chars.next()?; + if quote != '\'' && quote != '"' { + return None; + } + let end = original_rest[1..].find(quote)? + 1; + if !original_rest[end + 1..].trim().is_empty() { + return None; + } + let modes = &original_rest[1..end]; + Some( + modes + .split(',') + .map(|mode| mode.trim().to_ascii_uppercase()) + .filter(|mode| !mode.is_empty()) + .collect::>() + .join(","), + ) +} + +fn parse_select_session_sql_mode(sql: &str) -> Option { + let sql = sql.trim(); + if !sql.eq_ignore_ascii_case("select @@session.sql_mode") { + return None; + } + Some(sql["select".len()..].trim().to_string()) +} + +fn is_select_found_rows(sql: &str) -> bool { + let target = b"selectfound_rows()"; + let mut index = 0; + for byte in sql.bytes() { + if byte.is_ascii_whitespace() { + continue; + } + if target + .get(index) + .is_none_or(|expected| byte.to_ascii_lowercase() != *expected) + { + return false; + } + index += 1; + } + index == target.len() +} + +fn strip_sql_calc_found_rows(sql: &str) -> (String, Option) { + let Some(after_select) = strip_keyword(sql, "select") else { + return (sql.to_string(), None); + }; + let after_select = after_select.trim_start(); + let Some(after_sql_calc_found_rows) = strip_keyword(after_select, "sql_calc_found_rows") else { + return (sql.to_string(), None); + }; + + let sqlite_query = format!("SELECT {}", after_sql_calc_found_rows.trim_start()); + let count_query = strip_trailing_limit(&sqlite_query) + .unwrap_or(&sqlite_query) + .to_string(); + (sqlite_query, Some(count_query)) +} + +fn strip_trailing_limit(sql: &str) -> Option<&str> { + let lower = sql.to_ascii_lowercase(); + let index = lower.rfind(" limit ")?; + let tail = sql[index + " limit ".len()..].trim(); + if !is_simple_limit_tail(tail) { + return None; + } + Some(sql[..index].trim_end()) +} + +fn is_simple_limit_tail(tail: &str) -> bool { + let lower = tail.to_ascii_lowercase(); + let parts = lower.split_whitespace().collect::>(); + match parts.as_slice() { + [count] => is_digits(count), + [offset, count] => { + offset.ends_with(',') && is_digits(offset.trim_end_matches(',')) && is_digits(count) + } + [count, "offset", offset] => is_digits(count) && is_digits(offset), + _ => false, + } +} + +fn is_fast_select_passthrough_candidate(sql: &str) -> bool { + if strip_keyword(sql, "select").is_none() { + return false; + } + + let lower = sql.to_ascii_lowercase(); + if !lower.contains(" from ") { + return false; + } + + if lower.contains("information_schema") || lower.contains("_wp_sqlite_") { + return false; + } + + if !contains_allowed_table_after_keyword(sql, &lower, &["from", "join"]) { + return false; + } + + if has_common_passthrough_hazard(sql, &lower) { + return false; + } + + has_no_banned_select_construct(&lower) +} + +fn is_fast_update_passthrough_candidate(sql: &str) -> bool { + if strip_keyword(sql, "update").is_none() { + return false; + } + + let lower = sql.to_ascii_lowercase(); + if !contains_allowed_table_after_keyword(sql, &lower, &["update"]) { + return false; + } + + if !lower.contains(" set ") { + return false; + } + + if has_common_passthrough_hazard(sql, &lower) { + return false; + } + + !contains_any_ci( + &lower, + &[ + " low_priority ", + " ignore ", + " join ", + " order by ", + " limit ", + " match ", + " against ", + " collate ", + " interval ", + " rlike ", + " binary ", + ], + ) && has_no_banned_function(&lower) + && !contains_cast_as_signed(&lower) +} + +fn has_common_passthrough_hazard(sql: &str, lower: &str) -> bool { + sql.contains(';') + || sql.contains('\\') + || sql.contains('@') + || sql.contains("--") + || sql.contains("/*") + || sql.contains('#') + || sql.contains("->") + || contains_hex_literal(&lower) + || contains_charset_introducer(&lower) +} + +fn has_no_banned_select_construct(lower: &str) -> bool { + !contains_any_ci( + lower, + &[ + " union ", + " intersect ", + " except ", + " match ", + " against ", + " collate ", + " interval ", + " rlike ", + " binary ", + " for update", + " lock in share mode", + " use index", + " use key", + " force index", + " force key", + " ignore index", + " ignore key", + ], + ) && has_no_banned_function(lower) + && !contains_cast_as_signed(lower) + && (!lower.contains("sql_calc_found_rows") || strip_sql_calc_found_rows(lower).1.is_some()) +} + +fn has_no_banned_function(lower: &str) -> bool { + ![ + "if", + "concat", + "char_length", + "date_add", + "date_sub", + "date_format", + "str_to_date", + "rand", + "regexp", + "found_rows", + "database", + "version", + "last_insert_id", + "row_count", + "group_concat", + ] + .iter() + .any(|name| contains_function_call(lower, name)) +} + +fn contains_allowed_table_after_keyword(sql: &str, lower: &str, keywords: &[&str]) -> bool { + for keyword in keywords { + let mut search_from = 0; + while let Some(relative_index) = lower[search_from..].find(keyword) { + let index = search_from + relative_index; + let before_ok = index == 0 + || !lower.as_bytes()[index - 1].is_ascii_alphanumeric() + && lower.as_bytes()[index - 1] != b'_'; + let after_index = index + keyword.len(); + let after_ok = after_index >= lower.len() + || !lower.as_bytes()[after_index].is_ascii_alphanumeric() + && lower.as_bytes()[after_index] != b'_'; + if before_ok && after_ok { + let rest = &sql[after_index..]; + if let Some(table) = first_identifier(rest) { + if is_allowed_table_name(table) { + return true; + } + } + } + search_from = after_index; + } + } + false +} + +fn first_identifier(input: &str) -> Option<&str> { + let input = input.trim_start(); + let end = input + .find(|ch: char| ch.is_ascii_whitespace() || ch == ',' || ch == '(') + .unwrap_or(input.len()); + if end == 0 { + return None; + } + Some(&input[..end]) +} + +fn is_allowed_table_name(table: &str) -> bool { + let table = table + .trim_matches('`') + .rsplit('.') + .next() + .unwrap_or(table) + .trim_matches('`') + .to_ascii_lowercase(); + ALLOWED_TABLE_SUFFIXES.iter().any(|suffix| { + table == *suffix + || table + .strip_suffix(suffix) + .is_some_and(|prefix| prefix.ends_with('_')) + }) +} + +fn contains_any_ci(lower: &str, needles: &[&str]) -> bool { + needles.iter().any(|needle| lower.contains(needle)) +} + +fn strip_keyword<'a>(s: &'a str, keyword: &str) -> Option<&'a str> { + let head = s.get(..keyword.len())?; + if !head.eq_ignore_ascii_case(keyword) { + return None; + } + + let rest = &s[keyword.len()..]; + if rest + .as_bytes() + .first() + .is_some_and(|byte| byte.is_ascii_alphanumeric() || *byte == b'_') + { + return None; + } + Some(rest) +} + +fn is_digits(s: &str) -> bool { + !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit()) +} + +fn contains_function_call(lower: &str, name: &str) -> bool { + let bytes = lower.as_bytes(); + let mut search_from = 0; + while let Some(relative_index) = lower[search_from..].find(name) { + let index = search_from + relative_index; + let before_ok = index == 0 || !is_identifier_byte(bytes[index - 1]); + let mut after_index = index + name.len(); + while bytes.get(after_index).is_some_and(u8::is_ascii_whitespace) { + after_index += 1; + } + if before_ok && bytes.get(after_index) == Some(&b'(') { + return true; + } + search_from = index + name.len(); + } + false +} + +fn contains_cast_as_signed(lower: &str) -> bool { + contains_function_call(lower, "cast") + && (lower.contains(" as unsigned") || lower.contains(" as signed")) +} + +pub(crate) fn contains_sql_calc_found_rows(sql: &str) -> bool { + const NEEDLE: &[u8] = b"sql_calc_found_rows"; + sql.as_bytes() + .windows(NEEDLE.len()) + .any(|window| window.eq_ignore_ascii_case(NEEDLE)) +} + +fn is_identifier_byte(byte: u8) -> bool { + byte.is_ascii_alphanumeric() || byte == b'_' +} + +fn contains_hex_literal(lower: &str) -> bool { + lower.as_bytes().windows(2).enumerate().any(|(i, pair)| { + pair == b"0x" + && lower + .as_bytes() + .get(i + 2) + .is_some_and(u8::is_ascii_hexdigit) + }) +} + +fn contains_charset_introducer(lower: &str) -> bool { + ["_utf8", "_utf8mb4", "_latin1", "_binary"] + .iter() + .any(|needle| { + let mut search_from = 0; + while let Some(relative_index) = lower[search_from..].find(needle) { + let after_needle = search_from + relative_index + needle.len(); + let tail = lower[after_needle..].trim_start(); + if tail.starts_with('\'') { + return true; + } + search_from = after_needle; + } + false + }) +} + +#[cfg(test)] +mod tests { + use super::{translate_sqlite_plan, translate_sqlite_plan_code}; + + #[test] + fn translates_sql_calc_found_rows_select() { + assert_eq!( + translate_sqlite_plan( + b"SELECT SQL_CALC_FOUND_ROWS ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2", + ), + Some(vec![ + "select_passthrough".to_string(), + "SELECT ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2" + .to_string(), + "SELECT ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID".to_string(), + ]) + ); + assert_eq!( + translate_sqlite_plan_code( + b"SELECT SQL_CALC_FOUND_ROWS ID FROM wp_posts WHERE post_status = 'publish' ORDER BY ID LIMIT 0, 2", + ), + 0 + ); + } + + #[test] + fn translates_update_passthrough() { + assert_eq!( + translate_sqlite_plan( + b"UPDATE `wp_options` SET `option_value` = '1' WHERE `option_name` = 'x'", + ), + Some(vec![ + "update_passthrough".to_string(), + "UPDATE `wp_options` SET `option_value` = '1' WHERE `option_name` = 'x'" + .to_string(), + ]) + ); + assert_eq!( + translate_sqlite_plan_code( + b"UPDATE `wp_options` SET `option_value` = '1' WHERE `option_name` = 'x'", + ), + 2 + ); + } + + #[test] + fn translates_plain_select_to_original_query_code() { + assert_eq!( + translate_sqlite_plan_code(b"SELECT ID FROM wp_posts WHERE post_status = 'publish'"), + 1 + ); + } + + #[test] + fn translates_session_sql_mode_queries() { + assert_eq!( + translate_sqlite_plan(b"SET SESSION sql_mode = 'NO_ZERO_DATE, strict_trans_tables'"), + Some(vec![ + "set_session_sql_mode".to_string(), + "NO_ZERO_DATE,STRICT_TRANS_TABLES".to_string(), + ]) + ); + assert_eq!( + translate_sqlite_plan(b"SELECT @@session.SQL_mode"), + Some(vec![ + "select_session_sql_mode".to_string(), + "@@session.SQL_mode".to_string(), + ]) + ); + } + + #[test] + fn rejects_queries_that_need_mysql_translation() { + assert_eq!( + translate_sqlite_plan(b"SELECT * FROM information_schema.tables"), + None + ); + assert_eq!( + translate_sqlite_plan_code(b"SELECT * FROM information_schema.tables"), + 0 + ); + assert_eq!( + translate_sqlite_plan(b"SELECT CAST (meta_value AS UNSIGNED) FROM wp_postmeta"), + None + ); + assert_eq!( + translate_sqlite_plan(b"SELECT _utf8 'x' FROM wp_posts"), + None + ); + } +} diff --git a/packages/php-ext-wp-mysql-parser/tools/generate-compiled-packed-id-parser.php b/packages/php-ext-wp-mysql-parser/tools/generate-compiled-packed-id-parser.php new file mode 100644 index 000000000..9c1206a32 --- /dev/null +++ b/packages/php-ext-wp-mysql-parser/tools/generate-compiled-packed-id-parser.php @@ -0,0 +1,241 @@ + $part ) { + $lines[] = ' ' . $part . ( $index < $last_id ? ' |' : '' ); + } + $lines[] = ' )'; + return $lines; +} + +$out = array( + '// This file is generated from packages/mysql-on-sqlite/src/mysql/mysql-grammar.php.', + '// Regenerate with packages/php-ext-wp-mysql-parser/tools/generate-compiled-packed-id-parser.php.', + '#![allow(unused_mut, unused_variables)]', + '', + 'use super::lex;', + 'use super::native_ast_pack_kind_id;', + '', + 'pub const HIGHEST_TERMINAL_ID: i64 = ' . $highest_tid . 'i64;', + 'pub const QUERY_RULE_ID: i64 = ' . $query_id . 'i64;', + 'pub const SELECT_STATEMENT_RULE_ID: i64 = ' . $select_id . 'i64;', + '', + '#[derive(Clone, Copy, PartialEq, Eq)]', + 'enum CompiledMatch {', + ' No,', + ' Empty,', + ' Match,', + '}', + '', + "pub struct CompiledPackedIdStatsParser<'a> {", + " token_ids: &'a [i64],", + ' position: usize,', + ' descendants: i64,', + ' checksum: i64,', + '}', + '', + "impl<'a> CompiledPackedIdStatsParser<'a> {", + " pub fn new(token_ids: &'a [i64]) -> Self {", + ' Self {', + ' token_ids,', + ' position: 0,', + ' descendants: 0,', + ' checksum: 0,', + ' }', + ' }', + '', + ' pub fn parse(mut self) -> Option<(i64, i64)> {', + ' match self.parse_rule(QUERY_RULE_ID, true) {', + ' CompiledMatch::No => None,', + ' CompiledMatch::Empty | CompiledMatch::Match => Some((self.descendants, self.checksum)),', + ' }', + ' }', + '', + ' fn current_token_id(&self) -> i64 {', + ' self.token_ids.get(self.position).copied().unwrap_or(0)', + ' }', + '', + ' fn state(&self) -> (usize, i64, i64) {', + ' (self.position, self.descendants, self.checksum)', + ' }', + '', + ' fn restore(&mut self, state: (usize, i64, i64)) {', + ' self.position = state.0;', + ' self.descendants = state.1;', + ' self.checksum = state.2;', + ' }', + '', + ' fn push_node(&mut self, rule_id: i64) {', + ' self.descendants += 1;', + ' self.checksum += native_ast_pack_kind_id(0, rule_id);', + ' }', + '', + ' fn push_token(&mut self, token_id: i64) {', + ' self.descendants += 1;', + ' self.checksum += native_ast_pack_kind_id(1, token_id);', + ' }', + '', + ' fn parse_symbol(&mut self, symbol_id: i64) -> CompiledMatch {', + ' if symbol_id <= HIGHEST_TERMINAL_ID {', + ' if self.position >= self.token_ids.len() {', + ' return CompiledMatch::No;', + ' }', + ' if symbol_id == 0 {', + ' return CompiledMatch::Empty;', + ' }', + ' if self.token_ids[self.position] == symbol_id {', + ' self.position += 1;', + ' self.push_token(symbol_id);', + ' return CompiledMatch::Match;', + ' }', + ' return CompiledMatch::No;', + ' }', + ' self.parse_rule(symbol_id, false)', + ' }', + '', + ' fn parse_child(&mut self, symbol_id: i64, branch_matches: &mut bool, has_children: &mut bool) {', + ' if !*branch_matches {', + ' return;', + ' }', + ' let child_starting_descendants = self.descendants;', + ' match self.parse_symbol(symbol_id) {', + ' CompiledMatch::No => *branch_matches = false,', + ' CompiledMatch::Empty => {}', + ' CompiledMatch::Match => {', + ' if self.descendants != child_starting_descendants {', + ' *has_children = true;', + ' }', + ' }', + ' }', + ' }', + '', + ' fn parse_rule(&mut self, rule_id: i64, skip_current_node: bool) -> CompiledMatch {', + ' match rule_id {', +); + +foreach ( array_keys( $rules ) as $rule_id ) { + $out[] = ' ' . (int) $rule_id . 'i64 => self.parse_rule_' . (int) $rule_id . '(skip_current_node),'; +} +$out[] = ' _ => CompiledMatch::No,'; +$out[] = ' }'; +$out[] = ' }'; + +foreach ( $rules as $rule_id => $branches ) { + $rule_id = (int) $rule_id; + $rule_name = $rule_names[ $rule_id ] ?? ''; + $is_nullable = isset( $nullable[ $rule_id ] ); + $is_fragment = isset( $fragments[ $rule_id ] ); + + $out[] = ''; + $out[] = ' // ' . $rule_name; + $out[] = ' fn parse_rule_' . $rule_id . '(&mut self, skip_current_node: bool) -> CompiledMatch {'; + + if ( 0 === count( $branches ) ) { + $out[] = ' CompiledMatch::No'; + $out[] = ' }'; + continue; + } + + if ( $is_nullable ) { + $out[] = ' // Nullable rules may still match without consuming input.'; + } else { + $first_set = array_keys( $first_sets[ $rule_id ] ?? array() ); + $expr = rust_matches_expr( $first_set ); + if ( 1 === count( $expr ) ) { + $out[] = ' if !' . $expr[0] . ' {'; + } else { + $out[] = ' if !('; + foreach ( $expr as $line ) { + $out[] = $line; + } + $out[] = ' ) {'; + } + $out[] = ' return CompiledMatch::No;'; + $out[] = ' }'; + } + + $out[] = ''; + $out[] = ' let starting_state = self.state();'; + foreach ( $branches as $branch_index => $branch ) { + $out[] = ' // branch ' . $branch_index; + $out[] = ' self.restore(starting_state);'; + $out[] = ' let mut branch_matches = true;'; + $out[] = ' let mut has_children = false;'; + if ( ! $is_fragment ) { + $out[] = ' if !skip_current_node {'; + $out[] = ' self.push_node(' . $rule_id . 'i64);'; + $out[] = ' }'; + } + foreach ( $branch as $symbol ) { + $out[] = ' self.parse_child(' . (int) $symbol . 'i64, &mut branch_matches, &mut has_children);'; + } + if ( $rule_id === (int) $select_id ) { + $out[] = ' if branch_matches && self.current_token_id() == lex::INTO_SYMBOL {'; + $out[] = ' branch_matches = false;'; + $out[] = ' }'; + } + $out[] = ' if branch_matches {'; + $out[] = ' if has_children {'; + $out[] = ' return CompiledMatch::Match;'; + $out[] = ' }'; + $out[] = ' self.restore(starting_state);'; + $out[] = ' return CompiledMatch::Empty;'; + $out[] = ' }'; + $out[] = ''; + } + $out[] = ' self.restore(starting_state);'; + $out[] = ' CompiledMatch::No'; + $out[] = ' }'; +} + +$out[] = '}'; + +file_put_contents( $target, implode( "\n", $out ) . "\n" ); +printf( "Wrote %s\n", $target );