commit 625297106ef4263c7a53d47f9d341aeb941402ec Author: Lazar Bulovan Date: Sat Feb 14 15:05:12 2026 +0100 Inintal commit diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..88c9924 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,86 @@ +# AGENTS.md - SCL Language Server (Unified) + +This is a unified Neovim/LazyVim plugin for Siemens SCL language support. + +## Project Overview + +The unified `scl_lsp` project provides: +- **LSP Server** - Language Server Protocol implementation +- **Linter** - Diagnostics and code validation +- **Formatter** - Document formatting +- **Syntax Highlighting** - Tree-sitter based +- **Auto-completion** - blink.cmp integration +- **Auto-prefix** - Automatic `#` prefixing for variables + +## Project Structure + +``` +scl_lsp/ +├── src/ # LSP server implementation +│ ├── main.lua # Entry point, protocol handling +│ ├── parser.lua # Regex-based SCL parser +│ ├── treesitter.lua # Tree-sitter integration +│ ├── diagnostics.lua # Linter diagnostics +│ ├── formatter.lua # Document formatter +│ ├── json.lua # JSON encoder/decoder +│ └── plc_json.lua # External UDT loading +├── lua/ +│ ├── scl/ # Neovim plugin modules (from scl_syntax_nvim) +│ │ ├── init.lua +│ │ ├── auto_prefix.lua +│ │ ├── blink_cmp_source.lua +│ │ ├── fb_parser.lua +│ │ ├── udt_parser.lua +│ │ ├── variables.lua +│ │ └── workspace_types.lua +│ └── scl_lsp/ +│ ├── init.lua # Unified plugin setup +│ └── plugins/ +│ └── scl.lua # LazyVim plugin spec +├── queries/ # Tree-sitter queries +│ ├── highlights.scm +│ ├── indents.scm +│ ├── folds.scm +│ ├── locals.scm +│ └── tags.scm +├── grammar.js # Tree-sitter grammar +└── tree-sitter.json # Parser config +``` + +## Development + +### Running the LSP Server + +```bash +# Direct execution +lua src/main.lua + +# Via shell script +./scl_lsp.sh + +# With test mode +lua src/main.lua --test +``` + +### Testing + +```bash +# Tree-sitter parser +npm test +tree-sitter generate + +# Test file parsing +tree-sitter parse corpus/test/main_org_block.scl +``` + +### Key Patterns + +- **LSP Protocol**: JSON-RPC over stdin/stdout in `src/main.lua` +- **Diagnostics**: `src/diagnostics.lua` - validates SCL code +- **Formatter**: `src/formatter.lua` - formats SCL documents +- **Syntax**: Tree-sitter queries in `queries/` +- **Plugin Setup**: `lua/scl_lsp/init.lua` - LazyVim integration + +## Configuration + +See `README.md` for configuration options and usage. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..dd380a0 --- /dev/null +++ b/Makefile @@ -0,0 +1,10 @@ +.PHONY: start test clean + +start: + lua src/main.lua + +test: + lua src/main.lua --test + +clean: + rm -f *.o *.so diff --git a/README.md b/README.md new file mode 100644 index 0000000..8d65fbd --- /dev/null +++ b/README.md @@ -0,0 +1,228 @@ +# SCL Language Server - Unified Plugin for Siemens SCL + +A comprehensive Neovim/LazyVim plugin providing **Language Server Protocol (LSP)**, **Linting**, **Formatting**, and **Syntax Highlighting** for Siemens SCL (Structured Control Language) used in Siemens TIA Portal. + +## Features + +### LSP (Language Server Protocol) +| Feature | Description | +|---------|-------------| +| **Hover** | Press `K` to see variable type and struct fields | +| **Completion** | `#` for variables, `.` for struct fields, `(` for functions | +| **Go to Definition** | `gd` jump to variable declaration | +| **Document Symbols** | Shows functions, variables, types | +| **Workspace Symbols** | Search across all `.scl` files with fuzzy matching | +| **Semantic Tokens** | Keywords, variables highlighted | +| **Inlay Hints** | Shows variable types after declaration | +| **External UDT** | Load types from `.plc.json` or `data_types/` folder | + +### Linter (Diagnostics) +| Feature | Description | +|---------|-------------| +| **Undefined Variables** | Detects variables used without declaration | +| **Invalid # Prefix** | Detects `#` prefix in VAR sections | +| **Unknown Types** | Warns about unknown data types | +| **Type Validation** | Basic type checking | + +### Formatter +| Feature | Description | +|---------|-------------| +| **Document Formatting** | Format entire SCL files | +| **Indentation** | Proper block indentation | +| **Keyword Casing** | Maintains SCL keyword casing | + +### Syntax Highlighting +- Full SCL syntax support via tree-sitter +- ORGANIZATION_BLOCK, FUNCTION_BLOCK, FUNCTION definitions +- Variable declarations (VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT, VAR_TEMP, etc.) +- Control structures (IF/THEN/ELSE, CASE, FOR, WHILE, REPEAT) +- Code regions and comments +- All SCL data types and operators + +### Additional Features +| Feature | Description | +|---------|-------------| +| **Auto-Prefix** | Automatically adds `#` prefix to local variables (like TIA Portal) | +| **Workspace UDT Scanner** | Scans project for user-defined types | +| **blink.cmp Integration** | Smart completion source for blink.cmp | + +## Installation + +### LazyVim +```lua +-- ~/.config/nvim/lua/plugins/scl.lua +return { + "lazar/scl_lsp", + ft = "scl", + lazy = true, + dependencies = { + "neovim/nvim-lspconfig", + "nvim-treesitter/nvim-treesitter", + "saghen/blink.cmp", + }, + config = function() + require("scl_lsp").setup({ + -- LSP options + lsp = { + on_attach = function(client, bufnr) + -- custom keymaps + end, + }, + cmp = true, -- Enable blink.cmp integration + workspace_types = true, -- Enable workspace UDT scanning + auto_prefix = true, -- Enable auto-# prefixing + debug = false, + }) + end, +} +``` + +### Manual Setup +```lua +-- In your init.lua or plugin file +require("scl_lsp").setup({ + server_path = "/path/to/scl_lsp/src/main.lua", + cmp = true, + workspace_types = true, + auto_prefix = true, +}) +``` + +## Configuration Options + +| Option | Type | Default | Description | +|--------|------|---------|-------------| +| `server_path` | string | `~/dev/scl_lsp/src/main.lua` | Path to LSP server | +| `lsp.on_attach` | function | `nil` | Custom LSP attach callback | +| `lsp.formatting` | boolean | `false` | Enable format command | +| `cmp` | boolean | `true` | Enable blink.cmp integration | +| `workspace_types` | boolean | `true` | Enable workspace UDT scanning | +| `auto_prefix` | boolean | `true` | Enable auto-# prefixing | +| `project_root` | string | `nil` | Custom project root | +| `library_paths` | table | `{}` | Additional library paths | +| `debug` | boolean | `false` | Enable debug logging | + +## Commands + +| Command | Description | +|---------|-------------| +| `:SCLShowVariables` | Show local variables in current file | +| `:SCLShowWorkspaceTypes` | Show workspace UDTs and FB count | +| `:SCLRescanWorkspaceTypes` | Rescan workspace for types | +| `:SCLPrefixWord` | Manually prefix current word with `#` | +| `:LspSCLFormat` | Format current SCL file | +| `:SCLGeneratePlcJson` | Generate plc.data.json from data_types/ | + +## Keybindings + +| Key | Action | +|-----|--------| +| `K` | Hover (show variable info) | +| `gd` | Go to Definition | +| `s` | Document Symbols | +| `w` | Workspace Symbols | +| `fw` | Workspace Symbols (Telescope) | +| `ca` | Code Actions | + +## External UDT Support + +### Option 1: Create `.plc.json` +```json +{ + "dataTypes": [ + { + "name": "equipmentData", + "struct": [ + {"name": "id", "dataTypeName": "INT"}, + {"name": "status", "dataTypeName": "BOOL"}, + {"name": "temperature", "dataTypeName": "REAL"} + ] + } + ] +} +``` + +### Option 2: Auto-scan `data_types/` folder +The LSP automatically scans for SCL files in `data_types/` folder and extracts TYPE definitions. + +### Option 3: Generate `.plc.json` +```bash +lua /home/lazar/dev/scl_lsp/src/plc_json.lua --generate +``` + +## Project Structure + +``` +scl_lsp/ +├── README.md # This file +├── package.json # NPM scripts (tree-sitter) +├── Makefile # Build commands +├── grammar.js # Tree-sitter grammar +├── tree-sitter.json # Parser config +├── queries/ # Tree-sitter queries +│ ├── highlights.scm # Syntax highlighting +│ ├── indents.scm # Indentation +│ ├── folds.scm # Code folding +│ ├── locals.scm # Variable scoping +│ └── tags.scm # Navigation tags +├── src/ # LSP server +│ ├── main.lua # Main entry point +│ ├── parser.lua # Regex-based parser +│ ├── treesitter.lua # Tree-sitter integration +│ ├── json.lua # JSON encoder/decoder +│ ├── plc_json.lua # External UDT loading +│ ├── diagnostics.lua # Linter diagnostics +│ └── formatter.lua # Document formatter +└── lua/ + └── scl_lsp/ + ├── init.lua # Main plugin setup + ├── plugins/ + │ └── scl.lua # LazyVim plugin spec + └── scl/ # Syntax/completion modules + ├── init.lua + ├── auto_prefix.lua + ├── blink_cmp_source.lua + ├── fb_parser.lua + ├── udt_parser.lua + ├── variables.lua + └── workspace_types.lua +``` + +## Building Tree-sitter Parser + +```bash +# Generate parser from grammar.js +npm run build +# or: tree-sitter generate + +# Run tests +npm test +# or: tree-sitter test +``` + +## SCL Code Example + +```pascal +FUNCTION_BLOCK "Em101Sequence" +VAR + x : INT; + myVar : equipmentData; // User-defined type +END_VAR + +IF x > 5 THEN + myVar.id := 10; +END_IF + +myVar.status := TRUE; +myVar.temperature := 25.5; + +END_FUNCTION_BLOCK +``` + +## Requirements + +- **Neovim 0.9+** +- **nvim-lspconfig** - LSP client +- **nvim-treesitter** - Syntax highlighting +- **blink.cmp** - Optional, for completion +- **Lua 5.1+** - LSP server runtime diff --git a/generate_plc_json.lua b/generate_plc_json.lua new file mode 100644 index 0000000..88bc502 --- /dev/null +++ b/generate_plc_json.lua @@ -0,0 +1,66 @@ +#!/usr/bin/env lua +-- Generate plc.json from data_types folder +-- Usage: lua generate_plc_json.lua [--root ] [--output ] + +local args = {...} +local script_dir = debug.getinfo(1, "S").source:gsub("^@", ""):match("(.*/)") or "" +if script_dir == "" then script_dir = "." end + +local cwd = io.popen("pwd"):read("*l") +if script_dir:sub(1, 1) == "/" then + script_dir = script_dir:gsub("/+$", "") +elseif cwd then + script_dir = cwd .. "/" .. script_dir + script_dir = script_dir:gsub("/+", "/"):gsub("/$", "") +else + script_dir = "." +end + +package.path = package.path .. ";" .. script_dir .. "/?.lua;" .. script_dir .. "/src/?.lua" + +local json = dofile(script_dir .. "/src/json.lua") +local plc_json = dofile(script_dir .. "/src/plc_json.lua") + +local root_dir = script_dir +local output_file = script_dir .. "/plc.data.json" + +for i, arg in ipairs(args) do + if arg == "--root" and args[i+1] then + root_dir = args[i+1] + elseif arg == "--output" and args[i+1] then + output_file = args[i+1] + end +end + +local types = plc_json.load_types_from_workspace(root_dir) + +if next(types) == nil then + print("No types found in " .. root_dir) + os.exit(1) +end + +local dataTypes = {} +for _, typ in pairs(types) do + if typ.kind == "struct" then + local members = {} + for _, field in ipairs(typ.fields) do + table.insert(members, { name = field.name, dataTypeName = field.type }) + end + table.insert(dataTypes, { name = typ.name, struct = members }) + elseif typ.kind == "alias" then + table.insert(dataTypes, { name = typ.name, baseType = typ.base_type or "UNKNOWN" }) + end +end + +local output = { plcProject = { dataTypes = dataTypes } } +local content = json.encode(output) + +local file = io.open(output_file, "w") +if file then + file:write(content) + file:close() + print("Generated " .. output_file .. " with " .. #dataTypes .. " types") +else + print("Failed to write " .. output_file) + os.exit(1) +end diff --git a/grammar.js b/grammar.js new file mode 100644 index 0000000..b9b173b --- /dev/null +++ b/grammar.js @@ -0,0 +1,382 @@ +module.exports = grammar({ + name: 'scl', + + extras: $ => [ + /\s/, + $.line_comment, + $.block_comment, + $.c_style_comment + ], + + conflicts: $ => [ + [$.case_item], + [$.region_statement], + [$.region_name], + [$.case_statement], + [$.var_declaration, $.var_temp_declaration], + [$.var_declaration, $.var_constant_declaration], + [$.var_declaration, $.var_retain_declaration], + [$.var_declaration, $.var_non_retain_declaration] + ], + + rules: { + + source_file: $ => repeat( + choice( + $.organization_block, + $.function_block, + $.function, + $.statement + ) + ), + + organization_block: $ => seq( + 'ORGANIZATION_BLOCK', + field('name', $.string), + optional(seq('TITLE', '=', choice($.string, $.identifier))), + optional($.attribute_list), + optional(seq('VERSION', ':', $.number)), + repeat($.var_declaration), + 'BEGIN', + repeat($.statement), + 'END_ORGANIZATION_BLOCK' + ), + + function_block: $ => seq( + 'FUNCTION_BLOCK', + field('name', $.string), + optional(seq('TITLE', '=', choice($.string, $.identifier))), + optional($.attribute_list), + optional(seq('VERSION', ':', $.number)), + repeat($.var_declaration), + 'BEGIN', + repeat($.statement), + 'END_FUNCTION_BLOCK' + ), + + function: $ => seq( + 'FUNCTION', + field('name', $.string), + optional(seq(':', $.type)), + optional(seq('TITLE', '=', choice($.string, $.identifier))), + optional($.attribute_list), + optional(seq('VERSION', ':', $.number)), + repeat(choice( + $.var_declaration, + $.var_temp_declaration, + $.var_constant_declaration, + $.var_retain_declaration, + $.var_non_retain_declaration, + $.block_comment + )), + 'BEGIN', + repeat($.statement), + 'END_FUNCTION' + ), + + attribute_list: $ => seq( + '{', + $.attribute, + repeat(seq(choice(',', ';'), $.attribute)), + optional(choice(',', ';')), + '}' + ), + + attribute: $ => seq( + $.identifier, + ':=', + $.attribute_value + ), + + attribute_value: $ => choice( + $.string, + 'TRUE', 'FALSE', + $.identifier + ), + + var_declaration: $ => seq( + choice( + 'VAR_INPUT', + 'VAR_OUTPUT', + 'VAR_IN_OUT', + 'VAR', + 'VAR_TEMP', + seq('VAR', 'CONSTANT'), + seq('VAR', 'RETAIN'), + seq('VAR', 'NON_RETAIN'), + 'VAR_CONSTANT', + 'VAR_RETAIN', + 'VAR_NON_RETAIN' + ), + repeat(choice($.var_item, $.block_comment)), + 'END_VAR' + ), + + var_temp_declaration: $ => seq( + 'VAR_TEMP', + repeat(choice($.var_item, $.block_comment)), + 'END_VAR' + ), + + var_constant_declaration: $ => seq( + choice( + seq('VAR', 'CONSTANT'), + 'VAR_CONSTANT' + ), + repeat(choice($.var_item, $.block_comment)), + 'END_VAR' + ), + + var_retain_declaration: $ => seq( + choice( + seq('VAR', 'RETAIN'), + 'VAR_RETAIN' + ), + repeat(choice($.var_item, $.block_comment)), + 'END_VAR' + ), + + var_non_retain_declaration: $ => seq( + choice( + seq('VAR', 'NON_RETAIN'), + 'VAR_NON_RETAIN' + ), + repeat(choice($.var_item, $.block_comment)), + 'END_VAR' + ), + + var_item: $ => seq( + field('name', $.identifier), + optional($.attribute_list), + ':', + field('type', $.type), + optional(seq(':=', $.expression)), + ';' + ), + + type: $ => choice( + 'BOOL', 'Bool', + 'INT', 'Int', 'int', + 'DINT', 'DInt', 'dint', + 'SINT', 'SInt', 'sint', + 'USINT', 'USInt', 'usint', + 'UINT', 'UInt', 'uint', + 'WORD', 'Word', 'word', + 'DWORD', 'DWord', 'dword', + 'BYTE', 'Byte', 'byte', + 'REAL', 'Real', 'real', + 'LREAL', 'LReal', 'lreal', + 'TIME', 'Time', 'time', + 'TOD', 'Tod', 'tod', + 'DT', 'Dt', 'dt', + 'String', 'STRING', 'string', + seq(choice('String', 'STRING', 'string'), '[', $.number, ']'), + 'WString', 'WSTRING', 'wstring', + seq(choice('WString', 'WSTRING', 'wstring'), '[', $.number, ']'), + 'Char', 'CHAR', 'char', + 'WChar', 'WCHAR', 'wchar', + seq('ARRAY', '[', $.number, '..', $.number, ']', 'OF', $.type), + $.identifier, + $.string + ), + + statement: $ => choice( + $.assignment, + $.if_statement, + $.case_statement, + $.for_statement, + $.while_statement, + $.repeat_statement, + $.region_statement, + $.function_call, + $.exit_statement, + $.continue_statement, + $.empty_statement, + $.var_declaration, + $.var_temp_declaration, + $.var_constant_declaration, + $.var_retain_declaration, + $.var_non_retain_declaration + ), + + empty_statement: $ => ';', + + assignment: $ => seq( + field('target', $.lvalue), + ':=', + field('value', $.expression), + ';' + ), + + lvalue: $ => choice( + $.identifier, + $.prefixed_identifier, + $.field_access, + $.array_access, + $.function_name + ), + + function_name: $ => $.string, + + prefixed_identifier: $ => seq('#', $.identifier), + + field_access: $ => seq($.lvalue, '.', choice($.identifier, $.prefixed_identifier)), + + array_access: $ => seq($.lvalue, '[', $.expression, ']'), + + if_statement: $ => seq( + 'IF', $.expression, 'THEN', + repeat($.statement), + repeat($.elsif_clause), + optional($.else_clause), + 'END_IF' + ), + + elsif_clause: $ => seq( + 'ELSIF', $.expression, 'THEN', repeat($.statement) + ), + + else_clause: $ => seq('ELSE', repeat($.statement)), + + case_statement: $ => seq( + 'CASE', $.expression, 'OF', + repeat($.case_item), + optional($.else_clause), + 'END_CASE', + optional(';') + ), + + case_item: $ => seq( + choice($.number, $.identifier, $.prefixed_identifier, $.range), + ':', repeat($.statement) + ), + + range: $ => seq($.number, '..', $.number), + + for_statement: $ => seq( + 'FOR', $.identifier, ':=', $.expression, 'TO', $.expression, optional(seq('BY', $.expression)), 'DO', + repeat($.statement), + 'END_FOR' + ), + + while_statement: $ => seq( + 'WHILE', $.expression, 'DO', + repeat($.statement), + 'END_WHILE' + ), + + repeat_statement: $ => seq( + 'REPEAT', + repeat($.statement), + 'UNTIL', $.expression, 'END_REPEAT' + ), + + region_statement: $ => seq( + 'REGION', $.region_name, + repeat($.statement), + 'END_REGION', + optional($.region_name) + ), + + region_name: $ => repeat1( + choice( + $.identifier, + $.string, + '/', + '-' + ) + ), + + function_call: $ => seq( + choice($.identifier, $.string), + '(', + optional(seq( + $.parameter_list, + optional(seq('=>', $.identifier)) + )), + ')' + ), + + parameter_list: $ => seq( + $.parameter, + repeat(seq(',', $.parameter)) + ), + + parameter: $ => seq($.identifier, ':=', $.expression), + + expression: $ => choice( + $.number, + $.hex_number, + $.time_value, + $.identifier, + $.prefixed_identifier, + $.field_access, + $.array_access, + $.string, + $.function_call, + $.unary_expression, + $.binary_expression, + seq('(', $.expression, ')') + ), + + unary_expression: $ => prec.right(10, choice( + seq('NOT', $.expression), + seq('+', $.expression), + seq('-', $.expression) + )), + + binary_expression: $ => choice( + prec.left(2, seq($.expression, 'OR', $.expression)), + prec.left(3, seq($.expression, 'XOR', $.expression)), + prec.left(4, seq($.expression, 'AND', $.expression)), + prec.left(5, seq($.expression, choice('=', '<>'), $.expression)), + prec.left(6, seq($.expression, choice('<', '>', '<=', '>='), $.expression)), + prec.left(7, seq($.expression, choice('+', '-'), $.expression)), + prec.left(8, seq($.expression, choice('*', '/', 'MOD'), $.expression)) + ), + + number: $ => token(/\d+(\.\d+)?/), + + hex_number: $ => token(seq('16#', /[0-9A-Fa-f_]+/)), + + time_value: $ => token(seq('T#', /\d+(_?\d)*(ms|s|min|h)/)), + + string: $ => choice( + seq("'", repeat(choice(/[^'\n]/, "''")), "'"), + seq('"', repeat(choice(/[^"\n]/, '""')), '"') + ), + + // Support for STRING type with length: STRING[80] + string_type: $ => seq( + choice('STRING', 'String', 'string', 'WSTRING', 'WString', 'wstring'), + optional(seq('[', $.number, ']')) + ), + + // Support for SCL character literals: 'A', WCHAR#'B' + char_literal: $ => choice( + seq("'", /[^']/, "'"), + seq('WCHAR#', "'", /[^']/, "'") + ), + + identifier: $ => /[a-zA-Z_][a-zA-Z0-9_]*/, + + line_comment: $ => token(seq('//', /.*/)), + + block_comment: $ => token(seq( + '(*', + repeat(choice(/[^*]/, seq('*', /[^)]/))), + '*)' + )), + + c_style_comment: $ => token(seq( + '(/*', + repeat(choice(/[^*]/, seq('*', /[^)]/))), + '*/)' + )), + + exit_statement: $ => 'EXIT', + + continue_statement: $ => 'CONTINUE' + + } +}); diff --git a/package.json b/package.json new file mode 100644 index 0000000..047451e --- /dev/null +++ b/package.json @@ -0,0 +1,21 @@ +{ + "name": "scl-language-server", + "version": "0.1.0", + "description": "Language Server Protocol implementation for Siemens SCL", + "main": "src/main.lua", + "scripts": { + "start": "lua src/main.lua", + "test": "lua src/main.lua --test" + }, + "keywords": [ + "scl", + "lsp", + "siemens", + "TIA-Portal" + ], + "author": "", + "license": "MIT", + "dependencies": { + "lua-lsp": "^1.0.0" + } +} diff --git a/scl_lsp.sh b/scl_lsp.sh new file mode 100755 index 0000000..4361bf8 --- /dev/null +++ b/scl_lsp.sh @@ -0,0 +1,3 @@ +#!/bin/bash +cd /home/lazar/dev/scl_lsp +lua src/main.lua diff --git a/src/diagnostics.lua b/src/diagnostics.lua new file mode 100644 index 0000000..c976c77 --- /dev/null +++ b/src/diagnostics.lua @@ -0,0 +1,167 @@ +-- SCL Diagnostics - Linter functionality for the LSP server +local M = {} +local parser = require("scl_lsp.parser") + +local DiagnosticSeverity = { + Error = 1, + Warning = 2, + Information = 3, + Hint = 4, +} + +local function position_to_lsp(line, character) + return { + line = line, + character = character, + } +end + +local function range_to_lsp(start_line, start_char, end_line, end_char) + return { + start = position_to_lsp(start_line, start_char), + end = position_to_lsp(end_line, end_char), + } +end + +function M.validate_diagnostics(content, workspace_types, root_dir) + local diagnostics = {} + local lines = {} + for line in content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + local variables, _ = parser.extract_variables(content) + local types = parser.extract_types(content) + local functions = parser.extract_functions(content) + + local all_types = {} + for k, v in pairs(types) do all_types[k] = v end + for k, v in pairs(workspace_types or {}) do all_types[k] = v end + + local in_var_section = false + local var_section_start = nil + + for line_idx, line in ipairs(lines) do + local trimmed = line:gsub("^%s+", ""):gsub("%s+$", "") + local line_num = line_idx - 1 + + if trimmed:match("^VAR[_A-Z]*%s*$") or + trimmed:match("^VAR_INPUT%s*$") or + trimmed:match("^VAR_OUTPUT%s*$") or + trimmed:match("^VAR_IN_OUT%s*$") or + trimmed:match("^VAR_TEMP%s*$") or + trimmed:match("^VAR[_ ]*CONSTANT%s*$") or + trimmed:match("^VAR[_ ]*RETAIN%s*$") or + trimmed:match("^VAR[_ ]*NON_RETAIN%s*$") then + in_var_section = true + var_section_start = line_num + elseif trimmed:match("^END_VAR%s*$") then + in_var_section = false + var_section_start = nil + end + + if not in_var_section then + local hash_vars = {} + for var in line:gmatch("#[%w_]+") do + local var_name = var:sub(2) + hash_vars[var_name] = true + end + + for var_name, _ in pairs(hash_vars) do + if not variables[var_name] and not all_types[var_name] then + local var_start = line:find("#" .. var_name, 1, true) + if var_start then + table.insert(diagnostics, { + range = range_to_lsp(line_num, var_start - 1, line_num, var_start + #var_name - 1), + severity = DiagnosticSeverity.Error, + message = string.format("Undefined variable: %s", var_name), + code = "SCL001", + source = "scl_lsp", + }) + end + end + end + end + + if in_var_section and trimmed:match("^[%w_]+%s*:") then + local var_name = trimmed:match("^([%w_]+)%s*:") + local var_start = line:find(var_name, 1, true) + + if var_name and not var_name:match("^%d") then + local has_hash = line:match("#" .. var_name) + if has_hash then + table.insert(diagnostics, { + range = range_to_lsp(line_num, 0, line_num, #line), + severity = DiagnosticSeverity.Error, + message = "Variable declarations should NOT have '#' prefix in VAR section", + code = "SCL002", + source = "scl_lsp", + }) + end + + local type_part = line:match(":%s*([^;]+)") + if type_part then + type_part = type_part:gsub("%s*:=.*$", "") + type_part = type_part:gsub("%s*$", "") + type_part = type_part:gsub("^%s+", "") + + local base_type = type_part:match("^(%w+)") + if base_type and not all_types[base_type] and + base_type ~= "BOOL" and base_type ~= "INT" and base_type ~= "DINT" and + base_type ~= "REAL" and base_type ~= "LREAL" and base_type ~= "BYTE" and + base_type ~= "WORD" and base_type ~= "DWORD" and base_type ~= "LWORD" and + base_type ~= "CHAR" and base_type ~= "STRING" and base_type ~= "WCHAR" and + base_type ~= "WSTRING" and base_type ~= "TIME" and base_type ~= "DATE" and + base_type ~= "TIME_OF_DAY" and base_type ~= "DATE_AND_TIME" and + base_type ~= "S5TIME" and base_type ~= "LTIME" then + table.insert(diagnostics, { + range = range_to_lsp(line_num, 0, line_num, #line), + severity = DiagnosticSeverity.Warning, + message = string.format("Unknown data type: %s", base_type), + code = "SCL003", + source = "scl_lsp", + }) + end + end + end + end + + if trimmed:match("^%s*//") or trimmed:match("^%s*%(%*") then + -- Skip comments + else + for assignment in line:gmatch("#[%w_]+%s*:=") do + local var_name = assignment:match("#([%w_]+)") + if var_name and in_var_section then + local assign_start = line:find("#" .. var_name, 1, true) + table.insert(diagnostics, { + range = range_to_lsp(line_num, assign_start - 1, line_num, assign_start + #var_name), + severity = DiagnosticSeverity.Error, + message = "Cannot use '#' prefix for variables in VAR section", + code = "SCL004", + source = "scl_lsp", + }) + end + end + end + end + + for func_idx, func in ipairs(functions) do + local func_content = "" + for i = func.start + 1, func.final - 1 do + if lines[i + 1] then + func_content = func_content .. lines[i + 1] .. "\n" + end + end + + local func_vars, _ = parser.extract_variables(func_content) + local all_vars = {} + for k, v in pairs(variables) do all_vars[k] = v end + for k, v in pairs(func_vars) do + all_vars[k] = v + end + end + + return diagnostics +end + +return M diff --git a/src/formatter.lua b/src/formatter.lua new file mode 100644 index 0000000..81f405f --- /dev/null +++ b/src/formatter.lua @@ -0,0 +1,114 @@ +-- SCL Formatter - Document formatting for the LSP server +local M = {} + +local function position(line, character) + return { line = line, character = character } +end + +local function range(start_line, start_char, end_line, end_char) + return { + start = position(start_line, start_char), + end = position(end_line, end_char), + } +end + +function M.format_document(content, options) + options = options or {} + local indent_size = options.indentSize or 4 + local indent_char = options.insertSpaces and " " or "\t" + + local lines = {} + for line in content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + if #lines == 0 or content:sub(-1) ~= "\n" then + table.insert(lines, "") + end + + local formatted_lines = {} + local indent_level = 0 + + local function get_indent() + return string.rep(indent_char, indent_level * indent_size) + end + + local function is_block_keyword(line) + local kw = line:match('^%s*(%w+)') + if not kw then return false end + local block_keywords = { + IF = true, ELSIF = true, ELSE = true, + FOR = true, WHILE = true, REPEAT = true, + CASE = true, + FUNCTION = true, FUNCTION_BLOCK = true, ORGANIZATION_BLOCK = true, + TYPE = true, STRUCT = true, + } + return block_keywords[kw] + end + + local function is_end_block(line) + local kw = line:match('^%s*(%w+)') + if not kw then return false end + local end_keywords = { + END_IF = true, END_FOR = true, END_WHILE = true, END_REPEAT = true, + END_CASE = true, END_FUNCTION = true, END_FUNCTION_BLOCK = true, + END_ORGANIZATION_BLOCK = true, END_TYPE = true, END_STRUCT = true, + } + return end_keywords[kw] + end + + local function process_line(line) + local trimmed = line:gsub("^%s+", ""):gsub("%s+$", "") + + if trimmed == "" or trimmed:match("^//") or trimmed:match("^%(%*") then + table.insert(formatted_lines, line) + return + end + + if is_end_block(trimmed) then + indent_level = math.max(0, indent_level - 1) + end + + local formatted_line = get_indent() .. trimmed + table.insert(formatted_lines, formatted_line) + + if is_block_keyword(trimmed) and not is_end_block(trimmed) then + if not trimmed:match("CASE%s+.+OF%s*$") and + not trimmed:match("IF%s+.+THEN%s*$") and + not trimmed:match("ELSIF%s+.+THEN%s*$") and + not trimmed:match("ELSE%s*$") and + not trimmed:match("FOR%s+.+DO%s*$") and + not trimmed:match("WHILE%s+.+DO%s*$") and + not trimmed:match("REPEAT%s*$") then + indent_level = indent_level + 1 + end + end + end + + for _, line in ipairs(lines) do + process_line(line) + end + + local result = table.concat(formatted_lines, "\n") + if content:sub(-1) == "\n" then + result = result .. "\n" + end + + return { + { + range = range(0, 0, #lines, 0), + newText = result, + }, + } +end + +function M.get_formatting_options() + return { + insertSpaces = true, + tabSize = 4, + trimTrailingWhitespace = true, + insertFinalNewline = true, + trimFinalNewlines = true, + } +end + +return M diff --git a/src/grammar.json b/src/grammar.json new file mode 100644 index 0000000..8b7d996 --- /dev/null +++ b/src/grammar.json @@ -0,0 +1,2522 @@ +{ + "$schema": "https://tree-sitter.github.io/tree-sitter/assets/schemas/grammar.schema.json", + "name": "scl", + "rules": { + "source_file": { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "organization_block" + }, + { + "type": "SYMBOL", + "name": "function_block" + }, + { + "type": "SYMBOL", + "name": "function" + }, + { + "type": "SYMBOL", + "name": "statement" + } + ] + } + }, + "organization_block": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "ORGANIZATION_BLOCK" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "string" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "TITLE" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "attribute_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VERSION" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "number" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "var_declaration" + } + }, + { + "type": "STRING", + "value": "BEGIN" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "END_ORGANIZATION_BLOCK" + } + ] + }, + "function_block": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "FUNCTION_BLOCK" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "string" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "TITLE" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "attribute_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VERSION" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "number" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "var_declaration" + } + }, + { + "type": "STRING", + "value": "BEGIN" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "END_FUNCTION_BLOCK" + } + ] + }, + "function": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "FUNCTION" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "string" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "TITLE" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "attribute_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VERSION" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "number" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "var_declaration" + }, + { + "type": "SYMBOL", + "name": "var_temp_declaration" + }, + { + "type": "SYMBOL", + "name": "var_constant_declaration" + }, + { + "type": "SYMBOL", + "name": "var_retain_declaration" + }, + { + "type": "SYMBOL", + "name": "var_non_retain_declaration" + }, + { + "type": "SYMBOL", + "name": "block_comment" + } + ] + } + }, + { + "type": "STRING", + "value": "BEGIN" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "END_FUNCTION" + } + ] + }, + "attribute_list": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "attribute" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + { + "type": "SYMBOL", + "name": "attribute" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "attribute": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ":=" + }, + { + "type": "SYMBOL", + "name": "attribute_value" + } + ] + }, + "attribute_value": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "STRING", + "value": "TRUE" + }, + { + "type": "STRING", + "value": "FALSE" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + "var_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "VAR_INPUT" + }, + { + "type": "STRING", + "value": "VAR_OUTPUT" + }, + { + "type": "STRING", + "value": "VAR_IN_OUT" + }, + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "VAR_TEMP" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "CONSTANT" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "RETAIN" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "NON_RETAIN" + } + ] + }, + { + "type": "STRING", + "value": "VAR_CONSTANT" + }, + { + "type": "STRING", + "value": "VAR_RETAIN" + }, + { + "type": "STRING", + "value": "VAR_NON_RETAIN" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "var_item" + }, + { + "type": "SYMBOL", + "name": "block_comment" + } + ] + } + }, + { + "type": "STRING", + "value": "END_VAR" + } + ] + }, + "var_temp_declaration": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR_TEMP" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "var_item" + }, + { + "type": "SYMBOL", + "name": "block_comment" + } + ] + } + }, + { + "type": "STRING", + "value": "END_VAR" + } + ] + }, + "var_constant_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "CONSTANT" + } + ] + }, + { + "type": "STRING", + "value": "VAR_CONSTANT" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "var_item" + }, + { + "type": "SYMBOL", + "name": "block_comment" + } + ] + } + }, + { + "type": "STRING", + "value": "END_VAR" + } + ] + }, + "var_retain_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "RETAIN" + } + ] + }, + { + "type": "STRING", + "value": "VAR_RETAIN" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "var_item" + }, + { + "type": "SYMBOL", + "name": "block_comment" + } + ] + } + }, + { + "type": "STRING", + "value": "END_VAR" + } + ] + }, + "var_non_retain_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "VAR" + }, + { + "type": "STRING", + "value": "NON_RETAIN" + } + ] + }, + { + "type": "STRING", + "value": "VAR_NON_RETAIN" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "var_item" + }, + { + "type": "SYMBOL", + "name": "block_comment" + } + ] + } + }, + { + "type": "STRING", + "value": "END_VAR" + } + ] + }, + "var_item": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "attribute_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "type" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + "type": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "BOOL" + }, + { + "type": "STRING", + "value": "Bool" + }, + { + "type": "STRING", + "value": "INT" + }, + { + "type": "STRING", + "value": "Int" + }, + { + "type": "STRING", + "value": "int" + }, + { + "type": "STRING", + "value": "DINT" + }, + { + "type": "STRING", + "value": "DInt" + }, + { + "type": "STRING", + "value": "dint" + }, + { + "type": "STRING", + "value": "SINT" + }, + { + "type": "STRING", + "value": "SInt" + }, + { + "type": "STRING", + "value": "sint" + }, + { + "type": "STRING", + "value": "USINT" + }, + { + "type": "STRING", + "value": "USInt" + }, + { + "type": "STRING", + "value": "usint" + }, + { + "type": "STRING", + "value": "UINT" + }, + { + "type": "STRING", + "value": "UInt" + }, + { + "type": "STRING", + "value": "uint" + }, + { + "type": "STRING", + "value": "WORD" + }, + { + "type": "STRING", + "value": "Word" + }, + { + "type": "STRING", + "value": "word" + }, + { + "type": "STRING", + "value": "DWORD" + }, + { + "type": "STRING", + "value": "DWord" + }, + { + "type": "STRING", + "value": "dword" + }, + { + "type": "STRING", + "value": "BYTE" + }, + { + "type": "STRING", + "value": "Byte" + }, + { + "type": "STRING", + "value": "byte" + }, + { + "type": "STRING", + "value": "REAL" + }, + { + "type": "STRING", + "value": "Real" + }, + { + "type": "STRING", + "value": "real" + }, + { + "type": "STRING", + "value": "LREAL" + }, + { + "type": "STRING", + "value": "LReal" + }, + { + "type": "STRING", + "value": "lreal" + }, + { + "type": "STRING", + "value": "TIME" + }, + { + "type": "STRING", + "value": "Time" + }, + { + "type": "STRING", + "value": "time" + }, + { + "type": "STRING", + "value": "TOD" + }, + { + "type": "STRING", + "value": "Tod" + }, + { + "type": "STRING", + "value": "tod" + }, + { + "type": "STRING", + "value": "DT" + }, + { + "type": "STRING", + "value": "Dt" + }, + { + "type": "STRING", + "value": "dt" + }, + { + "type": "STRING", + "value": "String" + }, + { + "type": "STRING", + "value": "STRING" + }, + { + "type": "STRING", + "value": "string" + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "String" + }, + { + "type": "STRING", + "value": "STRING" + }, + { + "type": "STRING", + "value": "string" + } + ] + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + { + "type": "STRING", + "value": "WString" + }, + { + "type": "STRING", + "value": "WSTRING" + }, + { + "type": "STRING", + "value": "wstring" + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "WString" + }, + { + "type": "STRING", + "value": "WSTRING" + }, + { + "type": "STRING", + "value": "wstring" + } + ] + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + { + "type": "STRING", + "value": "Char" + }, + { + "type": "STRING", + "value": "CHAR" + }, + { + "type": "STRING", + "value": "char" + }, + { + "type": "STRING", + "value": "WChar" + }, + { + "type": "STRING", + "value": "WCHAR" + }, + { + "type": "STRING", + "value": "wchar" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "ARRAY" + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "STRING", + "value": ".." + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "STRING", + "value": "]" + }, + { + "type": "STRING", + "value": "OF" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "string" + } + ] + }, + "statement": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "assignment" + }, + { + "type": "SYMBOL", + "name": "if_statement" + }, + { + "type": "SYMBOL", + "name": "case_statement" + }, + { + "type": "SYMBOL", + "name": "for_statement" + }, + { + "type": "SYMBOL", + "name": "while_statement" + }, + { + "type": "SYMBOL", + "name": "repeat_statement" + }, + { + "type": "SYMBOL", + "name": "region_statement" + }, + { + "type": "SYMBOL", + "name": "function_call" + }, + { + "type": "SYMBOL", + "name": "exit_statement" + }, + { + "type": "SYMBOL", + "name": "continue_statement" + }, + { + "type": "SYMBOL", + "name": "empty_statement" + }, + { + "type": "SYMBOL", + "name": "var_declaration" + }, + { + "type": "SYMBOL", + "name": "var_temp_declaration" + }, + { + "type": "SYMBOL", + "name": "var_constant_declaration" + }, + { + "type": "SYMBOL", + "name": "var_retain_declaration" + }, + { + "type": "SYMBOL", + "name": "var_non_retain_declaration" + } + ] + }, + "empty_statement": { + "type": "STRING", + "value": ";" + }, + "assignment": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "target", + "content": { + "type": "SYMBOL", + "name": "lvalue" + } + }, + { + "type": "STRING", + "value": ":=" + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + "lvalue": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "prefixed_identifier" + }, + { + "type": "SYMBOL", + "name": "field_access" + }, + { + "type": "SYMBOL", + "name": "array_access" + }, + { + "type": "SYMBOL", + "name": "function_name" + } + ] + }, + "function_name": { + "type": "SYMBOL", + "name": "string" + }, + "prefixed_identifier": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + "field_access": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "lvalue" + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "prefixed_identifier" + } + ] + } + ] + }, + "array_access": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "lvalue" + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "if_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "IF" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "THEN" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "elsif_clause" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "else_clause" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "END_IF" + } + ] + }, + "elsif_clause": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "ELSIF" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "THEN" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + } + ] + }, + "else_clause": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "ELSE" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + } + ] + }, + "case_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "CASE" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "OF" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "case_item" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "else_clause" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "END_CASE" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "case_item": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "prefixed_identifier" + }, + { + "type": "SYMBOL", + "name": "range" + } + ] + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + } + ] + }, + "range": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "STRING", + "value": ".." + }, + { + "type": "SYMBOL", + "name": "number" + } + ] + }, + "for_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "FOR" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ":=" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "TO" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "BY" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "DO" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "END_FOR" + } + ] + }, + "while_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "WHILE" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "DO" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "END_WHILE" + } + ] + }, + "repeat_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "REPEAT" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "UNTIL" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "END_REPEAT" + } + ] + }, + "region_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "REGION" + }, + { + "type": "SYMBOL", + "name": "region_name" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "END_REGION" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "region_name" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "region_name": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "STRING", + "value": "/" + }, + { + "type": "STRING", + "value": "-" + } + ] + } + }, + "function_call": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "string" + } + ] + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "parameter_list" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "parameter_list": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "parameter" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "parameter" + } + ] + } + } + ] + }, + "parameter": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ":=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + "expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "SYMBOL", + "name": "hex_number" + }, + { + "type": "SYMBOL", + "name": "time_value" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "prefixed_identifier" + }, + { + "type": "SYMBOL", + "name": "field_access" + }, + { + "type": "SYMBOL", + "name": "array_access" + }, + { + "type": "SYMBOL", + "name": "string" + }, + { + "type": "SYMBOL", + "name": "function_call" + }, + { + "type": "SYMBOL", + "name": "unary_expression" + }, + { + "type": "SYMBOL", + "name": "binary_expression" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + }, + "unary_expression": { + "type": "PREC_RIGHT", + "value": 10, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "NOT" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "+" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "-" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + } + }, + "binary_expression": { + "type": "CHOICE", + "members": [ + { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "OR" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "XOR" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 4, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "AND" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 5, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "=" + }, + { + "type": "STRING", + "value": "<>" + } + ] + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 6, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "<" + }, + { + "type": "STRING", + "value": ">" + }, + { + "type": "STRING", + "value": "<=" + }, + { + "type": "STRING", + "value": ">=" + } + ] + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "+" + }, + { + "type": "STRING", + "value": "-" + } + ] + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "STRING", + "value": "/" + }, + { + "type": "STRING", + "value": "MOD" + } + ] + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + } + ] + }, + "number": { + "type": "TOKEN", + "content": { + "type": "PATTERN", + "value": "\\d+(\\.\\d+)?" + } + }, + "hex_number": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "16#" + }, + { + "type": "PATTERN", + "value": "[0-9A-Fa-f_]+" + } + ] + } + }, + "time_value": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "T#" + }, + { + "type": "PATTERN", + "value": "\\d+(_?\\d)*(ms|s|min|h)" + } + ] + } + }, + "string": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "'" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^'\\n]" + }, + { + "type": "STRING", + "value": "''" + } + ] + } + }, + { + "type": "STRING", + "value": "'" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\"" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^\"\\n]" + }, + { + "type": "STRING", + "value": "\"\"" + } + ] + } + }, + { + "type": "STRING", + "value": "\"" + } + ] + } + ] + }, + "string_type": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "STRING" + }, + { + "type": "STRING", + "value": "String" + }, + { + "type": "STRING", + "value": "string" + }, + { + "type": "STRING", + "value": "WSTRING" + }, + { + "type": "STRING", + "value": "WString" + }, + { + "type": "STRING", + "value": "wstring" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "number" + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "char_literal": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "'" + }, + { + "type": "PATTERN", + "value": "[^']" + }, + { + "type": "STRING", + "value": "'" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "WCHAR#" + }, + { + "type": "STRING", + "value": "'" + }, + { + "type": "PATTERN", + "value": "[^']" + }, + { + "type": "STRING", + "value": "'" + } + ] + } + ] + }, + "identifier": { + "type": "PATTERN", + "value": "[a-zA-Z_][a-zA-Z0-9_]*" + }, + "line_comment": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "//" + }, + { + "type": "PATTERN", + "value": ".*" + } + ] + } + }, + "block_comment": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(*" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^*]" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "PATTERN", + "value": "[^)]" + } + ] + } + ] + } + }, + { + "type": "STRING", + "value": "*)" + } + ] + } + }, + "c_style_comment": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(/*" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^*]" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "PATTERN", + "value": "[^)]" + } + ] + } + ] + } + }, + { + "type": "STRING", + "value": "*/)" + } + ] + } + }, + "exit_statement": { + "type": "STRING", + "value": "EXIT" + }, + "continue_statement": { + "type": "STRING", + "value": "CONTINUE" + } + }, + "extras": [ + { + "type": "PATTERN", + "value": "\\s" + }, + { + "type": "SYMBOL", + "name": "line_comment" + }, + { + "type": "SYMBOL", + "name": "block_comment" + }, + { + "type": "SYMBOL", + "name": "c_style_comment" + } + ], + "conflicts": [ + [ + "case_item" + ], + [ + "region_statement" + ], + [ + "region_name" + ], + [ + "case_statement" + ], + [ + "var_declaration", + "var_temp_declaration" + ], + [ + "var_declaration", + "var_constant_declaration" + ], + [ + "var_declaration", + "var_retain_declaration" + ], + [ + "var_declaration", + "var_non_retain_declaration" + ] + ], + "precedences": [], + "externals": [], + "inline": [], + "supertypes": [], + "reserved": {} +} \ No newline at end of file diff --git a/src/json.lua b/src/json.lua new file mode 100644 index 0000000..f69ebdc --- /dev/null +++ b/src/json.lua @@ -0,0 +1,195 @@ +local json = {} + +local function is_array(t) + local i = 0 + for _ in pairs(t) do + i = i + 1 + if t[i] == nil then + return false + end + end + return true +end + +local function escape(s) + s = s:gsub("\\", "\\\\") + s = s:gsub("\"", "\\\"") + s = s:gsub("\n", "\\n") + s = s:gsub("\r", "\\r") + s = s:gsub("\t", "\\t") + return s +end + +function json.encode(data) + local t = type(data) + if t == "nil" then + return "null" + elseif t == "boolean" then + return data and "true" or "false" + elseif t == "number" then + return tostring(data) + elseif t == "string" then + return "\"" .. escape(data) .. "\"" + elseif t == "table" then + local parts = {} + if is_array(data) then + for _, v in ipairs(data) do + table.insert(parts, json.encode(v)) + end + return "[" .. table.concat(parts, ",") .. "]" + else + for k, v in pairs(data) do + table.insert(parts, "\"" .. escape(k) .. "\":" .. json.encode(v)) + end + return "{" .. table.concat(parts, ",") .. "}" + end + else + return "null" + end +end + +local function skip_whitespace(s, i) + while i <= #s and s:find("^%s", i) do + i = i + 1 + end + return i +end + +local function parse_string(s, i) + local result = {} + i = i + 1 + while i <= #s do + local c = s:sub(i, i) + if c == "\"" then + return table.concat(result), i + 1 + elseif c == "\\" and i < #s then + local next_c = s:sub(i + 1, i + 1) + if next_c == "n" then + table.insert(result, "\n") + elseif next_c == "r" then + table.insert(result, "\r") + elseif next_c == "t" then + table.insert(result, "\t") + elseif next_c == "\\\"" then + table.insert(result, "\"") + elseif next_c == "\\\\" then + table.insert(result, "\\") + else + table.insert(result, next_c) + end + i = i + 2 + else + table.insert(result, c) + i = i + 1 + end + end + return nil, i +end + +local function parse_number(s, i) + local start = i + if s:sub(i, i) == "-" then + i = i + 1 + end + while i <= #s and s:find("^%d", s:sub(i, i)) do + i = i + 1 + end + if s:sub(i, i) == "." then + i = i + 1 + while i <= #s and s:find("^%d", s:sub(i, i)) do + i = i + 1 + end + end + if s:sub(i, i):find("^[eE]") then + i = i + 1 + if s:sub(i, i):find("^[+-]") then + i = i + 1 + end + while i <= #s and s:find("^%d", s:sub(i, i)) do + i = i + 1 + end + end + return tonumber(s:sub(start, i - 1)), i +end + +local function parse_value(s, i) + i = skip_whitespace(s, i) + if i > #s then + return nil, i + end + + local c = s:sub(i, i) + + if c == "{" then + local obj = {} + i = i + 1 + while i <= #s do + i = skip_whitespace(s, i) + if s:sub(i, i) == "}" then + return obj, i + 1 + end + if s:sub(i, i) == "\"" then + local key + key, i = parse_string(s, i) + i = skip_whitespace(s, i) + if s:sub(i, i) ~= ":" then + return nil, i + end + i = i + 1 + local val + val, i = parse_value(s, i) + obj[key] = val + i = skip_whitespace(s, i) + if s:sub(i, i) == "}" then + return obj, i + 1 + end + if s:sub(i, i) == "," then + i = i + 1 + end + else + return nil, i + end + end + return nil, i + elseif c == "[" then + local arr = {} + i = i + 1 + while i <= #s do + i = skip_whitespace(s, i) + if s:sub(i, i) == "]" then + return arr, i + 1 + end + local val + val, i = parse_value(s, i) + table.insert(arr, val) + i = skip_whitespace(s, i) + if s:sub(i, i) == "]" then + return arr, i + 1 + end + if s:sub(i, i) == "," then + i = i + 1 + end + end + return nil, i + elseif c == "\"" then + return parse_string(s, i) + elseif s:sub(i, i + 3) == "null" then + return nil, i + 4 + elseif s:sub(i, i + 3) == "true" then + return true, i + 4 + elseif s:sub(i, i + 4) == "false" then + return false, i + 5 + else + return parse_number(s, i) + end +end + +function json.decode(s) + if type(s) ~= "string" then + return nil, "invalid input" + end + local data, i = parse_value(s, 1) + return data, i +end + +return json diff --git a/src/main.lua b/src/main.lua new file mode 100644 index 0000000..1bbe0a8 --- /dev/null +++ b/src/main.lua @@ -0,0 +1,897 @@ +#!/usr/bin/env lua +-- SCL Language Server +-- Language Server Protocol implementation for Siemens SCL + +local script_path = debug.getinfo(1, "S").source:gsub("^@", ""):match("(.*/)") or "" +if script_path == "" then + script_path = "." +end + +local cwd = io.popen("pwd"):read("*l") + +if script_path:sub(1, 1) == "/" then + script_path = script_path:gsub("/+$", "") +elseif cwd then + script_path = cwd .. "/" .. script_path + script_path = script_path:gsub("/+", "/"):gsub("/$", "") +else + script_path = "." +end + +package.path = package.path .. ";" .. script_path .. "/?.lua" + +local json = dofile(script_path .. "/json.lua") +local parser = dofile(script_path .. "/parser.lua") +local treesitter = dofile(script_path .. "/treesitter.lua") +local plc_json = dofile(script_path .. "/plc_json.lua") +local diagnostics = dofile(script_path .. "/diagnostics.lua") +local formatter = dofile(script_path .. "/formatter.lua") + +local documents = {} + +local semanticTokenModifiers = {} +local semanticTokenTypes = { + "namespace", + "type", + "class", + "enum", + "interface", + "struct", + "typeParameter", + "parameter", + "variable", + "property", + "enumMember", + "event", + "func", + "method", + "macro", + "keyword", + "modifier", + "comment", + "string", + "number", + "operator", +} + +local capabilities = { + hoverProvider = true, + completionProvider = { + triggerCharacters = { ".", "#", "(" }, + resolveProvider = false, + }, + definitionProvider = true, + documentSymbolProvider = true, + diagnosticProvider = { relatedDocuments = {} }, + textDocumentSync = 1, + semanticTokensProvider = { + full = { delta = true }, + legend = { tokenTypes = semanticTokenTypes, tokenModifiers = semanticTokenModifiers }, + range = true, + }, + inlayHintProvider = { resolveProvider = false }, + workspaceSymbolProvider = true, + documentFormattingProvider = true, + documentRangeFormattingProvider = false, +} + +local function uri_to_path(uri) + return uri:gsub("^file://", ""):gsub("%%20", " ") +end + +local function path_to_uri(path) + return "file://" .. path:gsub(" ", "%%20") +end + +local function run_command(cmd) + local handle = io.popen(cmd) + if not handle then + return nil + end + local result = handle:read("*a") + handle:close() + return result +end + +local function scan_scl_files(root_dir) + local files = {} + if not root_dir or root_dir == "" then + return files + end + local result = run_command("find " .. root_dir .. ' -type f -name "*.scl" 2>/dev/null') + if result then + for f in result:gmatch("[^\n]+") do + if f and f ~= "" then + table.insert(files, f) + end + end + end + return files +end + +local function parse_scl_file(filepath) + local handle = io.open(filepath, "r") + if not handle then + return nil, nil, nil + end + local content = handle:read("*a") + handle:close() + + local variables = parser.extract_variables(content) + local functions = parser.extract_functions(content) + local types = parser.extract_types(content) + + return variables, functions, types +end + +local workspace_symbol_cache = {} +local function clear_symbol_cache() + workspace_symbol_cache = {} +end + +local function fuzzy_match(text, pattern) + if not text or not pattern then + return false + end + text = text:lower() + pattern = pattern:lower() + + local text_len = #text + local pattern_len = #pattern + local pattern_idx = 1 + + for i = 1, text_len do + if pattern_idx <= pattern_len and text:sub(i, i) == pattern:sub(pattern_idx, pattern_idx) then + pattern_idx = pattern_idx + 1 + end + end + + return pattern_idx > pattern_len +end + +local handlers = {} + +function handlers.initialize(params) + return { + capabilities = capabilities, + serverInfo = { name = "scl-language-server", version = "1.0.0" }, + } +end + +function handlers.initialized(params) end + +function handlers.shutdown(params) + return nil +end + +function handlers.exit(params) + os.exit(0) +end + +function handlers.textDocument_didOpen(params) + local uri = params.textDocument.uri + local content = params.textDocument.text + local path = uri_to_path(uri) + local root_dir = path:match("(.*/)") or "." + + local variables, var_positions = parser.extract_variables(content) + local functions = parser.extract_functions(content) + local types = parser.extract_types(content) + + local external_types = plc_json.get_types(root_dir) + for name, ext_type in pairs(external_types) do + if not types[name] then + types[name] = ext_type + end + end + + local tree = nil + local ts_ok = treesitter.init() + if ts_ok then + tree, _ = treesitter.parse_scl(content) + end + + documents[uri] = { + content = content, + version = params.textDocument.version, + path = path, + root_dir = root_dir, + variables = variables, + variable_positions = var_positions, + functions = functions, + types = types, + tree = tree, + } +end + +function handlers.textDocument_didChange(params) + local uri = params.textDocument.uri + local content = params.contentChanges[1].text + + local variables, var_positions = parser.extract_variables(content) + local functions = parser.extract_functions(content) + local types = parser.extract_types(content) + + local doc = documents[uri] + local root_dir = doc and doc.root_dir or "" + local external_types = plc_json.get_types(root_dir) + for name, ext_type in pairs(external_types) do + if not types[name] then + types[name] = ext_type + end + end + + local tree = nil + local ts_ok = treesitter.init() + if ts_ok then + tree, _ = treesitter.parse_scl(content) + end + + documents[uri] = { + content = content, + version = params.textDocument.version, + path = doc and doc.path or "", + root_dir = root_dir, + variables = variables, + variable_positions = var_positions, + functions = functions, + types = types, + tree = tree, + } + + clear_symbol_cache() +end + +function handlers.textDocument_didClose(params) + documents[params.textDocument.uri] = nil + clear_symbol_cache() +end + +function handlers.textDocument_hover(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return nil + end + + local lines = {} + for line in doc.content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + if #lines == 0 then + return nil + end + + local line_idx = params.position.line + 1 + if line_idx > #lines then + return nil + end + + local line = lines[line_idx] + local col = params.position.character + 1 + + local word_start = col + while word_start > 1 and line:sub(word_start - 1, word_start - 1):match("[%w_]") do + word_start = word_start - 1 + end + + local word_end = col + while word_end <= #line and line:sub(word_end, word_end):match("[%w_]") do + word_end = word_end + 1 + end + + local word = line:sub(word_start, word_end - 1) + local var_name = word:gsub("^#", "") + + if var_name ~= "" and doc.variables and doc.variables[var_name] then + local var_info = doc.variables[var_name] + local detail = string.format( + "**Local Variable** `#%s`\nScope: `%s`\nType: `%s`\nDeclared at line %d", + var_name, + var_info.type, + var_info.data_type or "unknown", + var_info.line + 1 + ) + return { + contents = { kind = "markdown", value = detail }, + range = { + start = { line = params.position.line, character = word_start - 1 }, + endPos = { line = params.position.line, character = word_end - 1 }, + }, + } + end + + if doc.types then + for type_name, type_info in pairs(doc.types) do + if type_name == word then + local detail = string.format("**Type**: `%s`\nKind: %s", type_name, type_info.kind) + if type_info.kind == "struct" and type_info.fields then + detail = detail .. "\n\n**Fields:**\n" + for _, field in ipairs(type_info.fields) do + detail = detail .. string.format("- `%s`: %s\n", field.name, field.type) + end + end + return { + contents = { kind = "markdown", value = detail }, + range = { + start = { line = params.position.line, character = word_start - 1 }, + endPos = { line = params.position.line, character = word_end - 1 }, + }, + } + end + end + end + + return nil +end + +function handlers.textDocument_completion(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return { items = {} } + end + + local items = {} + local lines = {} + for line in doc.content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + local line_idx = params.position.line + 1 + if line_idx <= #lines then + local line = lines[line_idx] + local col = params.position.character + local trigger = col > 0 and line:sub(col, col) or "" + + if trigger == "#" then + if doc.variables then + for name, info in pairs(doc.variables) do + table.insert(items, { + label = "#" .. name, + kind = 13, + detail = "Local variable (" .. (info.type or "unknown") .. ")", + insertText = "#" .. name, + insertTextFormat = 1, + }) + end + end + elseif trigger == "." then + local prefix_start = col - 1 + while prefix_start > 0 and line:sub(prefix_start, prefix_start):match("[%w_]") do + prefix_start = prefix_start - 1 + end + local prefix = line:sub(prefix_start + 1, col - 1) + + if prefix ~= "" then + local var_name = prefix:gsub("^#", "") + local var_info = doc.variables and doc.variables[var_name] + local data_type = var_info and var_info.data_type + + if data_type and doc.types then + local struct_name = data_type + if doc.types[struct_name] and doc.types[struct_name].fields then + for _, field in ipairs(doc.types[struct_name].fields) do + table.insert(items, { + label = field.name, + kind = 13, + detail = struct_name .. "." .. field.name .. ": " .. field.type, + insertText = field.name, + insertTextFormat = 1, + }) + end + end + end + end + + if #items == 0 then + local keywords = { + { label = "AND", detail = "Logical AND", kind = 14 }, + { label = "OR", detail = "Logical OR", kind = 14 }, + { label = "XOR", detail = "Logical XOR", kind = 14 }, + { label = "NOT", detail = "Logical NOT", kind = 14 }, + { label = "MOD", detail = "Modulo", kind = 14 }, + } + for _, kw in ipairs(keywords) do + table.insert(items, kw) + end + end + elseif trigger == "(" then + if doc.functions then + for _, func in ipairs(doc.functions) do + table.insert(items, { + label = func.name, + kind = 3, + detail = func.kind:upper(), + insertText = func.name .. "()", + insertTextFormat = 2, + }) + end + end + end + end + + return { isIncomplete = false, items = items } +end + +function handlers.textDocument_definition(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return nil + end + + local lines = {} + for line in doc.content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + if params.position.line + 1 > #lines then + return nil + end + + local line = lines[params.position.line + 1] + local col = params.position.character + 1 + + local word_start = col + while word_start > 1 and line:sub(word_start - 1, word_start - 1):match("[%w_]") do + word_start = word_start - 1 + end + + local word_end = col + while word_end <= #line and line:sub(word_end, word_end):match("[%w_]") do + word_end = word_end + 1 + end + + local word = line:sub(word_start, word_end - 1):gsub("^#", "") + if doc.variable_positions and doc.variable_positions[word] then + local pos = doc.variable_positions[word] + return { + uri = uri, + range = { + start = { line = pos.line, character = pos.character }, + endPos = { line = pos.line, character = pos.character + #word }, + }, + } + end + return nil +end + +function handlers.textDocument_documentSymbol(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return {} + end + + local symbols = {} + local kind_map = { + ["function"] = 14, + ["function_block"] = 11, + ["organization_block"] = 25, + ["struct"] = 23, + ["alias"] = 7, + ["array"] = 24, + } + + if doc.functions then + for _, func in ipairs(doc.functions) do + table.insert(symbols, { + name = func.kind:upper() .. " " .. func.name, + kind = kind_map[func.kind] or 14, + range = { start = { line = func.start, character = 0 }, endPos = { line = func.final, character = 0 } }, + selectionRange = { + start = { line = func.start, character = 0 }, + endPos = { line = func.start, character = #func.name }, + }, + containerName = nil, + }) + end + end + + if doc.variables then + for var_name, var_info in pairs(doc.variables) do + local var_kind = 13 + if var_info.type and (var_info.type:find("CONSTANT") or var_info.type:find("RETAIN")) then + var_kind = 26 + end + table.insert(symbols, { + name = "#" .. var_name, + kind = var_kind, + detail = var_info.type or "VAR", + range = { + start = { line = var_info.line, character = 0 }, + endPos = { line = var_info.line, character = #var_name }, + }, + selectionRange = { + start = { line = var_info.line, character = var_info.character }, + endPos = { line = var_info.line, character = var_info.character + #var_name }, + }, + containerName = nil, + }) + end + end + + if doc.types then + for type_name, type_info in pairs(doc.types) do + local kind = kind_map[type_info.kind] or 7 + local detail = type_info.kind:upper() + if type_info.kind == "alias" and type_info.base_type then + detail = detail .. " (" .. type_info.base_type .. ")" + elseif type_info.kind == "struct" and type_info.fields and #type_info.fields > 0 then + detail = detail .. " (" .. #type_info.fields .. " fields)" + end + table.insert(symbols, { + name = "TYPE " .. type_name, + kind = kind, + detail = detail, + range = { + start = { line = type_info.start_line or 0, character = 0 }, + endPos = { line = type_info.start_line or 0, character = #type_name }, + }, + selectionRange = { + start = { line = type_info.start_line or 0, character = 0 }, + endPos = { line = type_info.start_line or 0, character = #type_name }, + }, + containerName = nil, + }) + end + end + + return symbols +end + +function handlers.textDocument_diagnostic(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return { items = {} } + end + + local external_types = {} + if doc.root_dir then + external_types = plc_json.get_types(doc.root_dir) + end + + local diag_results = diagnostics.validate_diagnostics(doc.content, external_types, doc.root_dir) + return { items = diag_results } +end + +function handlers.textDocument_semanticTokensFull(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return { data = {} } + end + + local tokens = {} + local lines = {} + for line in doc.content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + local function add_token(line, startChar, length, tokenType) + local deltaLine = line + local deltaStart = startChar + if #tokens >= 4 then + local prevLine = tokens[#tokens - 3] + local prevStart = tokens[#tokens - 2] + if line == prevLine then + deltaLine = 0 + deltaStart = startChar - prevStart + else + deltaLine = line - prevLine + end + end + table.insert(tokens, deltaLine) + table.insert(tokens, deltaStart) + table.insert(tokens, length) + table.insert(tokens, 0) + table.insert(tokens, 0) + end + + for i, line in ipairs(lines) do + local lineNum = i - 1 + local trimmed = line:gsub("^%s+", "") + + if doc.variables then + for var_name, info in pairs(doc.variables) do + if info.line == lineNum then + local startChar = line:find(var_name, 1, true) + if startChar then + add_token(lineNum, startChar - 1, #var_name, "variable") + end + end + end + end + + local keywords = { + "IF", + "THEN", + "ELSIF", + "ELSE", + "END_IF", + "FOR", + "TO", + "BY", + "DO", + "END_FOR", + "WHILE", + "END_WHILE", + "REPEAT", + "UNTIL", + "END_REPEAT", + "CASE", + "OF", + "END_CASE", + "VAR_INPUT", + "VAR_OUTPUT", + "VAR_IN_OUT", + "VAR_TEMP", + "VAR", + "END_VAR", + "BEGIN", + "EXIT", + "CONTINUE", + "RETURN", + "TRUE", + "FALSE", + } + for _, kw in ipairs(keywords) do + local startPos = line:find("%f[%a]" .. kw .. "%f[%A]") + if startPos then + add_token(lineNum, startPos - 1, #kw, "keyword") + end + end + end + + return { data = tokens } +end + +function handlers.textDocument_semanticTokensRange(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return { data = {} } + end + return handlers.textDocument_semanticTokensFull(params) +end + +function handlers.textDocument_inlayHint(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return {} + end + + local hints = {} + local lines = {} + for line in doc.content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + for i, line in ipairs(lines) do + local lineNum = i - 1 + if doc.variables then + for var_name, info in pairs(doc.variables) do + if info.line == lineNum and info.data_type and info.data_type ~= "unknown" then + local colonPos = line:find(":", 1, true) + if colonPos then + table.insert(hints, { + position = { line = lineNum, character = #line }, + label = ": " .. info.data_type, + kind = 1, + paddingLeft = true, + }) + end + end + end + end + end + return hints +end + +function handlers.workspace_symbol(params) + local query = params.query or "" + local max_results = params.maxResults or 50 + + if query == "" then + return {} + end + + local results = {} + + local function add_result(name, kind, uri, line, col, length) + table.insert(results, { + name = name, + kind = kind, + location = { + uri = uri, + range = { + start = { line = line, character = col }, + endPos = { line = line, character = col + length }, + }, + }, + }) + end + + for uri, doc in pairs(documents) do + if doc.functions then + for _, func in ipairs(doc.functions) do + if fuzzy_match(func.name, query) or fuzzy_match(func.kind, query) then + add_result( + func.kind:upper() .. " " .. func.name, + func.kind == "function" and 14 or (func.kind == "function_block" and 11 or 25), + uri, + func.start, + 0, + #func.name + ) + end + end + end + + if doc.variables then + for var_name, var_info in pairs(doc.variables) do + if fuzzy_match(var_name, query) then + add_result("#" .. var_name, 13, uri, var_info.line, var_info.character, #var_name) + end + end + end + + if doc.types then + for type_name, type_info in pairs(doc.types) do + if fuzzy_match(type_name, query) then + local kind = 7 + if type_info.kind == "struct" then + kind = 23 + elseif type_info.kind == "array" then + kind = 24 + end + add_result("TYPE " .. type_name, kind, uri, type_info.start_line or 0, 0, #type_name) + end + end + end + end + + local scanned_dirs = {} + for _, doc in pairs(documents) do + if doc.root_dir and doc.root_dir ~= "" then + scanned_dirs[doc.root_dir] = true + end + end + + local function search_file(filepath) + local cached_file = filepath + if not workspace_symbol_cache[":file:" .. cached_file] then + local variables, functions, types = parse_scl_file(filepath) + workspace_symbol_cache[":file:" .. cached_file] = { + variables = variables, + functions = functions, + types = types, + } + end + + local cached_data = workspace_symbol_cache[":file:" .. cached_file] + local file_uri = path_to_uri(filepath) + + if cached_data.functions then + for _, func in ipairs(cached_data.functions) do + if fuzzy_match(func.name, query) or fuzzy_match(func.kind, query) then + add_result( + func.kind:upper() .. " " .. func.name, + func.kind == "function" and 14 or (func.kind == "function_block" and 11 or 25), + file_uri, + func.start, + 0, + #func.name + ) + end + end + end + + if cached_data.variables then + for var_name, var_info in pairs(cached_data.variables) do + if fuzzy_match(var_name, query) then + add_result("#" .. var_name, 13, file_uri, var_info.line, var_info.character, #var_name) + end + end + end + + if cached_data.types then + for type_name, type_info in pairs(cached_data.types) do + if fuzzy_match(type_name, query) then + local kind = 7 + if type_info.kind == "struct" then + kind = 23 + elseif type_info.kind == "array" then + kind = 24 + end + add_result("TYPE " .. type_name, kind, file_uri, type_info.start_line or 0, 0, #type_name) + end + end + end + end + + for root_dir, _ in pairs(scanned_dirs) do + local scl_files = scan_scl_files(root_dir) + for _, filepath in ipairs(scl_files) do + search_file(filepath) + end + end + + local final_results = {} + for i = 1, math.min(#results, max_results) do + table.insert(final_results, results[i]) + end + + return final_results +end + +function handlers.textDocument_formatting(params) + local uri = params.textDocument.uri + local doc = documents[uri] + if not doc then + return nil + end + + local options = params.options or {} + local format_options = { + insertSpaces = options.insertSpaces, + tabSize = options.tabSize, + indentSize = options.tabSize or 4, + } + + return formatter.format_document(doc.content, format_options) +end + +local function handle_message(message) + if message.method == "$/cancelRequest" then + return nil + end + local handler = handlers[message.method] + if handler then + local ok, result = pcall(handler, message.params) + if ok then + return { id = message.id, result = result } + else + return { id = message.id, error = { code = -32603, message = tostring(result) } } + end + else + return { id = message.id, error = { code = -32601, message = "Method not found: " .. message.method } } + end +end + +local function main() + local stdin = io.input() + local stdout = io.output() + local content_length = nil + + while true do + local line = stdin:read("*l") + if not line then + break + end + if line:match("^Content%-Length:%s*(%d+)") then + content_length = tonumber(line:match("^Content%-Length:%s*(%d+)")) + elseif line == "" then + if content_length then + local body = stdin:read(content_length) + local message = json.decode(body) + if message.method == "exit" then + break + end + local response = handle_message(message) + if response then + local response_body = json.encode(response) + stdout:write("Content-Length: " .. #response_body .. "\r\n") + stdout:write("Content-Type: application/json\r\n\r\n") + stdout:write(response_body) + stdout:flush() + end + content_length = nil + end + end + end +end + +main() diff --git a/src/node-types.json b/src/node-types.json new file mode 100644 index 0000000..22af526 --- /dev/null +++ b/src/node-types.json @@ -0,0 +1,1555 @@ +[ + { + "type": "array_access", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "lvalue", + "named": true + } + ] + } + }, + { + "type": "assignment", + "named": true, + "fields": { + "target": { + "multiple": false, + "required": true, + "types": [ + { + "type": "lvalue", + "named": true + } + ] + }, + "value": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + } + }, + { + "type": "attribute", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "attribute_value", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "attribute_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "attribute", + "named": true + } + ] + } + }, + { + "type": "attribute_value", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "binary_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "case_item", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "prefixed_identifier", + "named": true + }, + { + "type": "range", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "case_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "case_item", + "named": true + }, + { + "type": "else_clause", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "else_clause", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "elsif_clause", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "empty_statement", + "named": true, + "fields": {} + }, + { + "type": "expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array_access", + "named": true + }, + { + "type": "binary_expression", + "named": true + }, + { + "type": "expression", + "named": true + }, + { + "type": "field_access", + "named": true + }, + { + "type": "function_call", + "named": true + }, + { + "type": "hex_number", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "prefixed_identifier", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "time_value", + "named": true + }, + { + "type": "unary_expression", + "named": true + } + ] + } + }, + { + "type": "field_access", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "lvalue", + "named": true + }, + { + "type": "prefixed_identifier", + "named": true + } + ] + } + }, + { + "type": "for_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "function", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "attribute_list", + "named": true + }, + { + "type": "block_comment", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "statement", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "type", + "named": true + }, + { + "type": "var_constant_declaration", + "named": true + }, + { + "type": "var_declaration", + "named": true + }, + { + "type": "var_non_retain_declaration", + "named": true + }, + { + "type": "var_retain_declaration", + "named": true + }, + { + "type": "var_temp_declaration", + "named": true + } + ] + } + }, + { + "type": "function_block", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "attribute_list", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "statement", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "var_declaration", + "named": true + } + ] + } + }, + { + "type": "function_call", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "parameter_list", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "function_name", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "if_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "else_clause", + "named": true + }, + { + "type": "elsif_clause", + "named": true + }, + { + "type": "expression", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "lvalue", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array_access", + "named": true + }, + { + "type": "field_access", + "named": true + }, + { + "type": "function_name", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "prefixed_identifier", + "named": true + } + ] + } + }, + { + "type": "organization_block", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "attribute_list", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "statement", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "var_declaration", + "named": true + } + ] + } + }, + { + "type": "parameter", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "parameter_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "parameter", + "named": true + } + ] + } + }, + { + "type": "prefixed_identifier", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "range", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "number", + "named": true + } + ] + } + }, + { + "type": "region_name", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "region_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "region_name", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "repeat_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "source_file", + "named": true, + "root": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "function", + "named": true + }, + { + "type": "function_block", + "named": true + }, + { + "type": "organization_block", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "statement", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "assignment", + "named": true + }, + { + "type": "case_statement", + "named": true + }, + { + "type": "continue_statement", + "named": true + }, + { + "type": "empty_statement", + "named": true + }, + { + "type": "exit_statement", + "named": true + }, + { + "type": "for_statement", + "named": true + }, + { + "type": "function_call", + "named": true + }, + { + "type": "if_statement", + "named": true + }, + { + "type": "region_statement", + "named": true + }, + { + "type": "repeat_statement", + "named": true + }, + { + "type": "var_constant_declaration", + "named": true + }, + { + "type": "var_declaration", + "named": true + }, + { + "type": "var_non_retain_declaration", + "named": true + }, + { + "type": "var_retain_declaration", + "named": true + }, + { + "type": "var_temp_declaration", + "named": true + }, + { + "type": "while_statement", + "named": true + } + ] + } + }, + { + "type": "string", + "named": true, + "fields": {} + }, + { + "type": "type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "number", + "named": true + }, + { + "type": "string", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "unary_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "var_constant_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_comment", + "named": true + }, + { + "type": "var_item", + "named": true + } + ] + } + }, + { + "type": "var_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_comment", + "named": true + }, + { + "type": "var_item", + "named": true + } + ] + } + }, + { + "type": "var_item", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "type": { + "multiple": false, + "required": true, + "types": [ + { + "type": "type", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "attribute_list", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "var_non_retain_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_comment", + "named": true + }, + { + "type": "var_item", + "named": true + } + ] + } + }, + { + "type": "var_retain_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_comment", + "named": true + }, + { + "type": "var_item", + "named": true + } + ] + } + }, + { + "type": "var_temp_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "block_comment", + "named": true + }, + { + "type": "var_item", + "named": true + } + ] + } + }, + { + "type": "while_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "statement", + "named": true + } + ] + } + }, + { + "type": "\"", + "named": false + }, + { + "type": "\"\"", + "named": false + }, + { + "type": "#", + "named": false + }, + { + "type": "'", + "named": false + }, + { + "type": "''", + "named": false + }, + { + "type": "(", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": "*", + "named": false + }, + { + "type": "+", + "named": false + }, + { + "type": ",", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": ".", + "named": false + }, + { + "type": "..", + "named": false + }, + { + "type": "/", + "named": false + }, + { + "type": ":", + "named": false + }, + { + "type": ":=", + "named": false + }, + { + "type": ";", + "named": false + }, + { + "type": "<", + "named": false + }, + { + "type": "<=", + "named": false + }, + { + "type": "<>", + "named": false + }, + { + "type": "=", + "named": false + }, + { + "type": "=>", + "named": false + }, + { + "type": ">", + "named": false + }, + { + "type": ">=", + "named": false + }, + { + "type": "AND", + "named": false + }, + { + "type": "ARRAY", + "named": false + }, + { + "type": "BEGIN", + "named": false + }, + { + "type": "BOOL", + "named": false + }, + { + "type": "BY", + "named": false + }, + { + "type": "BYTE", + "named": false + }, + { + "type": "Bool", + "named": false + }, + { + "type": "Byte", + "named": false + }, + { + "type": "CASE", + "named": false + }, + { + "type": "CHAR", + "named": false + }, + { + "type": "CONSTANT", + "named": false + }, + { + "type": "Char", + "named": false + }, + { + "type": "DINT", + "named": false + }, + { + "type": "DInt", + "named": false + }, + { + "type": "DO", + "named": false + }, + { + "type": "DT", + "named": false + }, + { + "type": "DWORD", + "named": false + }, + { + "type": "DWord", + "named": false + }, + { + "type": "Dt", + "named": false + }, + { + "type": "ELSE", + "named": false + }, + { + "type": "ELSIF", + "named": false + }, + { + "type": "END_CASE", + "named": false + }, + { + "type": "END_FOR", + "named": false + }, + { + "type": "END_FUNCTION", + "named": false + }, + { + "type": "END_FUNCTION_BLOCK", + "named": false + }, + { + "type": "END_IF", + "named": false + }, + { + "type": "END_ORGANIZATION_BLOCK", + "named": false + }, + { + "type": "END_REGION", + "named": false + }, + { + "type": "END_REPEAT", + "named": false + }, + { + "type": "END_VAR", + "named": false + }, + { + "type": "END_WHILE", + "named": false + }, + { + "type": "FALSE", + "named": false + }, + { + "type": "FOR", + "named": false + }, + { + "type": "FUNCTION", + "named": false + }, + { + "type": "FUNCTION_BLOCK", + "named": false + }, + { + "type": "IF", + "named": false + }, + { + "type": "INT", + "named": false + }, + { + "type": "Int", + "named": false + }, + { + "type": "LREAL", + "named": false + }, + { + "type": "LReal", + "named": false + }, + { + "type": "MOD", + "named": false + }, + { + "type": "NON_RETAIN", + "named": false + }, + { + "type": "NOT", + "named": false + }, + { + "type": "OF", + "named": false + }, + { + "type": "OR", + "named": false + }, + { + "type": "ORGANIZATION_BLOCK", + "named": false + }, + { + "type": "REAL", + "named": false + }, + { + "type": "REGION", + "named": false + }, + { + "type": "REPEAT", + "named": false + }, + { + "type": "RETAIN", + "named": false + }, + { + "type": "Real", + "named": false + }, + { + "type": "SINT", + "named": false + }, + { + "type": "SInt", + "named": false + }, + { + "type": "STRING", + "named": false + }, + { + "type": "String", + "named": false + }, + { + "type": "THEN", + "named": false + }, + { + "type": "TIME", + "named": false + }, + { + "type": "TITLE", + "named": false + }, + { + "type": "TO", + "named": false + }, + { + "type": "TOD", + "named": false + }, + { + "type": "TRUE", + "named": false + }, + { + "type": "Time", + "named": false + }, + { + "type": "Tod", + "named": false + }, + { + "type": "UINT", + "named": false + }, + { + "type": "UInt", + "named": false + }, + { + "type": "UNTIL", + "named": false + }, + { + "type": "USINT", + "named": false + }, + { + "type": "USInt", + "named": false + }, + { + "type": "VAR", + "named": false + }, + { + "type": "VAR_CONSTANT", + "named": false + }, + { + "type": "VAR_INPUT", + "named": false + }, + { + "type": "VAR_IN_OUT", + "named": false + }, + { + "type": "VAR_NON_RETAIN", + "named": false + }, + { + "type": "VAR_OUTPUT", + "named": false + }, + { + "type": "VAR_RETAIN", + "named": false + }, + { + "type": "VAR_TEMP", + "named": false + }, + { + "type": "VERSION", + "named": false + }, + { + "type": "WCHAR", + "named": false + }, + { + "type": "WChar", + "named": false + }, + { + "type": "WHILE", + "named": false + }, + { + "type": "WORD", + "named": false + }, + { + "type": "WSTRING", + "named": false + }, + { + "type": "WString", + "named": false + }, + { + "type": "Word", + "named": false + }, + { + "type": "XOR", + "named": false + }, + { + "type": "[", + "named": false + }, + { + "type": "]", + "named": false + }, + { + "type": "block_comment", + "named": true, + "extra": true + }, + { + "type": "byte", + "named": false + }, + { + "type": "c_style_comment", + "named": true, + "extra": true + }, + { + "type": "char", + "named": false + }, + { + "type": "continue_statement", + "named": true + }, + { + "type": "dint", + "named": false + }, + { + "type": "dt", + "named": false + }, + { + "type": "dword", + "named": false + }, + { + "type": "exit_statement", + "named": true + }, + { + "type": "hex_number", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "int", + "named": false + }, + { + "type": "line_comment", + "named": true, + "extra": true + }, + { + "type": "lreal", + "named": false + }, + { + "type": "number", + "named": true + }, + { + "type": "real", + "named": false + }, + { + "type": "sint", + "named": false + }, + { + "type": "string", + "named": false + }, + { + "type": "time", + "named": false + }, + { + "type": "time_value", + "named": true + }, + { + "type": "tod", + "named": false + }, + { + "type": "uint", + "named": false + }, + { + "type": "usint", + "named": false + }, + { + "type": "wchar", + "named": false + }, + { + "type": "word", + "named": false + }, + { + "type": "wstring", + "named": false + }, + { + "type": "{", + "named": false + }, + { + "type": "}", + "named": false + } +] \ No newline at end of file diff --git a/src/parser.c b/src/parser.c new file mode 100644 index 0000000..2ea571b --- /dev/null +++ b/src/parser.c @@ -0,0 +1,67456 @@ +/* Automatically @generated by tree-sitter */ + +#include "tree_sitter/parser.h" + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#ifdef _MSC_VER +#pragma optimize("", off) +#elif defined(__clang__) +#pragma clang optimize off +#elif defined(__GNUC__) +#pragma GCC optimize ("O0") +#endif + +#define LANGUAGE_VERSION 15 +#define STATE_COUNT 1762 +#define LARGE_STATE_COUNT 2 +#define SYMBOL_COUNT 194 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 142 +#define EXTERNAL_TOKEN_COUNT 0 +#define FIELD_COUNT 4 +#define MAX_ALIAS_SEQUENCE_LENGTH 15 +#define MAX_RESERVED_WORD_SET_SIZE 0 +#define PRODUCTION_ID_COUNT 5 +#define SUPERTYPE_COUNT 0 + +enum ts_symbol_identifiers { + anon_sym_ORGANIZATION_BLOCK = 1, + anon_sym_TITLE = 2, + anon_sym_EQ = 3, + anon_sym_VERSION = 4, + anon_sym_COLON = 5, + anon_sym_BEGIN = 6, + anon_sym_END_ORGANIZATION_BLOCK = 7, + anon_sym_FUNCTION_BLOCK = 8, + anon_sym_END_FUNCTION_BLOCK = 9, + anon_sym_FUNCTION = 10, + anon_sym_END_FUNCTION = 11, + anon_sym_LBRACE = 12, + anon_sym_COMMA = 13, + anon_sym_SEMI = 14, + anon_sym_RBRACE = 15, + anon_sym_COLON_EQ = 16, + anon_sym_TRUE = 17, + anon_sym_FALSE = 18, + anon_sym_VAR_INPUT = 19, + anon_sym_VAR_OUTPUT = 20, + anon_sym_VAR_IN_OUT = 21, + anon_sym_VAR = 22, + anon_sym_VAR_TEMP = 23, + anon_sym_CONSTANT = 24, + anon_sym_RETAIN = 25, + anon_sym_NON_RETAIN = 26, + anon_sym_VAR_CONSTANT = 27, + anon_sym_VAR_RETAIN = 28, + anon_sym_VAR_NON_RETAIN = 29, + anon_sym_END_VAR = 30, + anon_sym_BOOL = 31, + anon_sym_Bool = 32, + anon_sym_INT = 33, + anon_sym_Int = 34, + anon_sym_int = 35, + anon_sym_DINT = 36, + anon_sym_DInt = 37, + anon_sym_dint = 38, + anon_sym_SINT = 39, + anon_sym_SInt = 40, + anon_sym_sint = 41, + anon_sym_USINT = 42, + anon_sym_USInt = 43, + anon_sym_usint = 44, + anon_sym_UINT = 45, + anon_sym_UInt = 46, + anon_sym_uint = 47, + anon_sym_WORD = 48, + anon_sym_Word = 49, + anon_sym_word = 50, + anon_sym_DWORD = 51, + anon_sym_DWord = 52, + anon_sym_dword = 53, + anon_sym_BYTE = 54, + anon_sym_Byte = 55, + anon_sym_byte = 56, + anon_sym_REAL = 57, + anon_sym_Real = 58, + anon_sym_real = 59, + anon_sym_LREAL = 60, + anon_sym_LReal = 61, + anon_sym_lreal = 62, + anon_sym_TIME = 63, + anon_sym_Time = 64, + anon_sym_time = 65, + anon_sym_TOD = 66, + anon_sym_Tod = 67, + anon_sym_tod = 68, + anon_sym_DT = 69, + anon_sym_Dt = 70, + anon_sym_dt = 71, + anon_sym_String = 72, + anon_sym_STRING = 73, + anon_sym_string = 74, + anon_sym_LBRACK = 75, + anon_sym_RBRACK = 76, + anon_sym_WString = 77, + anon_sym_WSTRING = 78, + anon_sym_wstring = 79, + anon_sym_Char = 80, + anon_sym_CHAR = 81, + anon_sym_char = 82, + anon_sym_WChar = 83, + anon_sym_WCHAR = 84, + anon_sym_wchar = 85, + anon_sym_ARRAY = 86, + anon_sym_DOT_DOT = 87, + anon_sym_OF = 88, + anon_sym_POUND = 89, + anon_sym_DOT = 90, + anon_sym_IF = 91, + anon_sym_THEN = 92, + anon_sym_END_IF = 93, + anon_sym_ELSIF = 94, + anon_sym_ELSE = 95, + anon_sym_CASE = 96, + anon_sym_END_CASE = 97, + anon_sym_FOR = 98, + anon_sym_TO = 99, + anon_sym_BY = 100, + anon_sym_DO = 101, + anon_sym_END_FOR = 102, + anon_sym_WHILE = 103, + anon_sym_END_WHILE = 104, + anon_sym_REPEAT = 105, + anon_sym_UNTIL = 106, + anon_sym_END_REPEAT = 107, + anon_sym_REGION = 108, + anon_sym_END_REGION = 109, + anon_sym_SLASH = 110, + anon_sym_DASH = 111, + anon_sym_LPAREN = 112, + anon_sym_EQ_GT = 113, + anon_sym_RPAREN = 114, + anon_sym_NOT = 115, + anon_sym_PLUS = 116, + anon_sym_OR = 117, + anon_sym_XOR = 118, + anon_sym_AND = 119, + anon_sym_LT_GT = 120, + anon_sym_LT = 121, + anon_sym_GT = 122, + anon_sym_LT_EQ = 123, + anon_sym_GT_EQ = 124, + anon_sym_STAR = 125, + anon_sym_MOD = 126, + sym_number = 127, + sym_hex_number = 128, + sym_time_value = 129, + anon_sym_SQUOTE = 130, + aux_sym_string_token1 = 131, + anon_sym_SQUOTE_SQUOTE = 132, + anon_sym_DQUOTE = 133, + aux_sym_string_token2 = 134, + anon_sym_DQUOTE_DQUOTE = 135, + sym_identifier = 136, + sym_line_comment = 137, + sym_block_comment = 138, + sym_c_style_comment = 139, + sym_exit_statement = 140, + sym_continue_statement = 141, + sym_source_file = 142, + sym_organization_block = 143, + sym_function_block = 144, + sym_function = 145, + sym_attribute_list = 146, + sym_attribute = 147, + sym_attribute_value = 148, + sym_var_declaration = 149, + sym_var_temp_declaration = 150, + sym_var_constant_declaration = 151, + sym_var_retain_declaration = 152, + sym_var_non_retain_declaration = 153, + sym_var_item = 154, + sym_type = 155, + sym_statement = 156, + sym_empty_statement = 157, + sym_assignment = 158, + sym_lvalue = 159, + sym_function_name = 160, + sym_prefixed_identifier = 161, + sym_field_access = 162, + sym_array_access = 163, + sym_if_statement = 164, + sym_elsif_clause = 165, + sym_else_clause = 166, + sym_case_statement = 167, + sym_case_item = 168, + sym_range = 169, + sym_for_statement = 170, + sym_while_statement = 171, + sym_repeat_statement = 172, + sym_region_statement = 173, + sym_region_name = 174, + sym_function_call = 175, + sym_parameter_list = 176, + sym_parameter = 177, + sym_expression = 178, + sym_unary_expression = 179, + sym_binary_expression = 180, + sym_string = 181, + aux_sym_source_file_repeat1 = 182, + aux_sym_organization_block_repeat1 = 183, + aux_sym_organization_block_repeat2 = 184, + aux_sym_function_repeat1 = 185, + aux_sym_attribute_list_repeat1 = 186, + aux_sym_var_declaration_repeat1 = 187, + aux_sym_if_statement_repeat1 = 188, + aux_sym_case_statement_repeat1 = 189, + aux_sym_region_name_repeat1 = 190, + aux_sym_parameter_list_repeat1 = 191, + aux_sym_string_repeat1 = 192, + aux_sym_string_repeat2 = 193, +}; + +static const char * const ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [anon_sym_ORGANIZATION_BLOCK] = "ORGANIZATION_BLOCK", + [anon_sym_TITLE] = "TITLE", + [anon_sym_EQ] = "=", + [anon_sym_VERSION] = "VERSION", + [anon_sym_COLON] = ":", + [anon_sym_BEGIN] = "BEGIN", + [anon_sym_END_ORGANIZATION_BLOCK] = "END_ORGANIZATION_BLOCK", + [anon_sym_FUNCTION_BLOCK] = "FUNCTION_BLOCK", + [anon_sym_END_FUNCTION_BLOCK] = "END_FUNCTION_BLOCK", + [anon_sym_FUNCTION] = "FUNCTION", + [anon_sym_END_FUNCTION] = "END_FUNCTION", + [anon_sym_LBRACE] = "{", + [anon_sym_COMMA] = ",", + [anon_sym_SEMI] = ";", + [anon_sym_RBRACE] = "}", + [anon_sym_COLON_EQ] = ":=", + [anon_sym_TRUE] = "TRUE", + [anon_sym_FALSE] = "FALSE", + [anon_sym_VAR_INPUT] = "VAR_INPUT", + [anon_sym_VAR_OUTPUT] = "VAR_OUTPUT", + [anon_sym_VAR_IN_OUT] = "VAR_IN_OUT", + [anon_sym_VAR] = "VAR", + [anon_sym_VAR_TEMP] = "VAR_TEMP", + [anon_sym_CONSTANT] = "CONSTANT", + [anon_sym_RETAIN] = "RETAIN", + [anon_sym_NON_RETAIN] = "NON_RETAIN", + [anon_sym_VAR_CONSTANT] = "VAR_CONSTANT", + [anon_sym_VAR_RETAIN] = "VAR_RETAIN", + [anon_sym_VAR_NON_RETAIN] = "VAR_NON_RETAIN", + [anon_sym_END_VAR] = "END_VAR", + [anon_sym_BOOL] = "BOOL", + [anon_sym_Bool] = "Bool", + [anon_sym_INT] = "INT", + [anon_sym_Int] = "Int", + [anon_sym_int] = "int", + [anon_sym_DINT] = "DINT", + [anon_sym_DInt] = "DInt", + [anon_sym_dint] = "dint", + [anon_sym_SINT] = "SINT", + [anon_sym_SInt] = "SInt", + [anon_sym_sint] = "sint", + [anon_sym_USINT] = "USINT", + [anon_sym_USInt] = "USInt", + [anon_sym_usint] = "usint", + [anon_sym_UINT] = "UINT", + [anon_sym_UInt] = "UInt", + [anon_sym_uint] = "uint", + [anon_sym_WORD] = "WORD", + [anon_sym_Word] = "Word", + [anon_sym_word] = "word", + [anon_sym_DWORD] = "DWORD", + [anon_sym_DWord] = "DWord", + [anon_sym_dword] = "dword", + [anon_sym_BYTE] = "BYTE", + [anon_sym_Byte] = "Byte", + [anon_sym_byte] = "byte", + [anon_sym_REAL] = "REAL", + [anon_sym_Real] = "Real", + [anon_sym_real] = "real", + [anon_sym_LREAL] = "LREAL", + [anon_sym_LReal] = "LReal", + [anon_sym_lreal] = "lreal", + [anon_sym_TIME] = "TIME", + [anon_sym_Time] = "Time", + [anon_sym_time] = "time", + [anon_sym_TOD] = "TOD", + [anon_sym_Tod] = "Tod", + [anon_sym_tod] = "tod", + [anon_sym_DT] = "DT", + [anon_sym_Dt] = "Dt", + [anon_sym_dt] = "dt", + [anon_sym_String] = "String", + [anon_sym_STRING] = "STRING", + [anon_sym_string] = "string", + [anon_sym_LBRACK] = "[", + [anon_sym_RBRACK] = "]", + [anon_sym_WString] = "WString", + [anon_sym_WSTRING] = "WSTRING", + [anon_sym_wstring] = "wstring", + [anon_sym_Char] = "Char", + [anon_sym_CHAR] = "CHAR", + [anon_sym_char] = "char", + [anon_sym_WChar] = "WChar", + [anon_sym_WCHAR] = "WCHAR", + [anon_sym_wchar] = "wchar", + [anon_sym_ARRAY] = "ARRAY", + [anon_sym_DOT_DOT] = "..", + [anon_sym_OF] = "OF", + [anon_sym_POUND] = "#", + [anon_sym_DOT] = ".", + [anon_sym_IF] = "IF", + [anon_sym_THEN] = "THEN", + [anon_sym_END_IF] = "END_IF", + [anon_sym_ELSIF] = "ELSIF", + [anon_sym_ELSE] = "ELSE", + [anon_sym_CASE] = "CASE", + [anon_sym_END_CASE] = "END_CASE", + [anon_sym_FOR] = "FOR", + [anon_sym_TO] = "TO", + [anon_sym_BY] = "BY", + [anon_sym_DO] = "DO", + [anon_sym_END_FOR] = "END_FOR", + [anon_sym_WHILE] = "WHILE", + [anon_sym_END_WHILE] = "END_WHILE", + [anon_sym_REPEAT] = "REPEAT", + [anon_sym_UNTIL] = "UNTIL", + [anon_sym_END_REPEAT] = "END_REPEAT", + [anon_sym_REGION] = "REGION", + [anon_sym_END_REGION] = "END_REGION", + [anon_sym_SLASH] = "/", + [anon_sym_DASH] = "-", + [anon_sym_LPAREN] = "(", + [anon_sym_EQ_GT] = "=>", + [anon_sym_RPAREN] = ")", + [anon_sym_NOT] = "NOT", + [anon_sym_PLUS] = "+", + [anon_sym_OR] = "OR", + [anon_sym_XOR] = "XOR", + [anon_sym_AND] = "AND", + [anon_sym_LT_GT] = "<>", + [anon_sym_LT] = "<", + [anon_sym_GT] = ">", + [anon_sym_LT_EQ] = "<=", + [anon_sym_GT_EQ] = ">=", + [anon_sym_STAR] = "*", + [anon_sym_MOD] = "MOD", + [sym_number] = "number", + [sym_hex_number] = "hex_number", + [sym_time_value] = "time_value", + [anon_sym_SQUOTE] = "'", + [aux_sym_string_token1] = "string_token1", + [anon_sym_SQUOTE_SQUOTE] = "''", + [anon_sym_DQUOTE] = "\"", + [aux_sym_string_token2] = "string_token2", + [anon_sym_DQUOTE_DQUOTE] = "\"\"", + [sym_identifier] = "identifier", + [sym_line_comment] = "line_comment", + [sym_block_comment] = "block_comment", + [sym_c_style_comment] = "c_style_comment", + [sym_exit_statement] = "exit_statement", + [sym_continue_statement] = "continue_statement", + [sym_source_file] = "source_file", + [sym_organization_block] = "organization_block", + [sym_function_block] = "function_block", + [sym_function] = "function", + [sym_attribute_list] = "attribute_list", + [sym_attribute] = "attribute", + [sym_attribute_value] = "attribute_value", + [sym_var_declaration] = "var_declaration", + [sym_var_temp_declaration] = "var_temp_declaration", + [sym_var_constant_declaration] = "var_constant_declaration", + [sym_var_retain_declaration] = "var_retain_declaration", + [sym_var_non_retain_declaration] = "var_non_retain_declaration", + [sym_var_item] = "var_item", + [sym_type] = "type", + [sym_statement] = "statement", + [sym_empty_statement] = "empty_statement", + [sym_assignment] = "assignment", + [sym_lvalue] = "lvalue", + [sym_function_name] = "function_name", + [sym_prefixed_identifier] = "prefixed_identifier", + [sym_field_access] = "field_access", + [sym_array_access] = "array_access", + [sym_if_statement] = "if_statement", + [sym_elsif_clause] = "elsif_clause", + [sym_else_clause] = "else_clause", + [sym_case_statement] = "case_statement", + [sym_case_item] = "case_item", + [sym_range] = "range", + [sym_for_statement] = "for_statement", + [sym_while_statement] = "while_statement", + [sym_repeat_statement] = "repeat_statement", + [sym_region_statement] = "region_statement", + [sym_region_name] = "region_name", + [sym_function_call] = "function_call", + [sym_parameter_list] = "parameter_list", + [sym_parameter] = "parameter", + [sym_expression] = "expression", + [sym_unary_expression] = "unary_expression", + [sym_binary_expression] = "binary_expression", + [sym_string] = "string", + [aux_sym_source_file_repeat1] = "source_file_repeat1", + [aux_sym_organization_block_repeat1] = "organization_block_repeat1", + [aux_sym_organization_block_repeat2] = "organization_block_repeat2", + [aux_sym_function_repeat1] = "function_repeat1", + [aux_sym_attribute_list_repeat1] = "attribute_list_repeat1", + [aux_sym_var_declaration_repeat1] = "var_declaration_repeat1", + [aux_sym_if_statement_repeat1] = "if_statement_repeat1", + [aux_sym_case_statement_repeat1] = "case_statement_repeat1", + [aux_sym_region_name_repeat1] = "region_name_repeat1", + [aux_sym_parameter_list_repeat1] = "parameter_list_repeat1", + [aux_sym_string_repeat1] = "string_repeat1", + [aux_sym_string_repeat2] = "string_repeat2", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [anon_sym_ORGANIZATION_BLOCK] = anon_sym_ORGANIZATION_BLOCK, + [anon_sym_TITLE] = anon_sym_TITLE, + [anon_sym_EQ] = anon_sym_EQ, + [anon_sym_VERSION] = anon_sym_VERSION, + [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_BEGIN] = anon_sym_BEGIN, + [anon_sym_END_ORGANIZATION_BLOCK] = anon_sym_END_ORGANIZATION_BLOCK, + [anon_sym_FUNCTION_BLOCK] = anon_sym_FUNCTION_BLOCK, + [anon_sym_END_FUNCTION_BLOCK] = anon_sym_END_FUNCTION_BLOCK, + [anon_sym_FUNCTION] = anon_sym_FUNCTION, + [anon_sym_END_FUNCTION] = anon_sym_END_FUNCTION, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_SEMI] = anon_sym_SEMI, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_COLON_EQ] = anon_sym_COLON_EQ, + [anon_sym_TRUE] = anon_sym_TRUE, + [anon_sym_FALSE] = anon_sym_FALSE, + [anon_sym_VAR_INPUT] = anon_sym_VAR_INPUT, + [anon_sym_VAR_OUTPUT] = anon_sym_VAR_OUTPUT, + [anon_sym_VAR_IN_OUT] = anon_sym_VAR_IN_OUT, + [anon_sym_VAR] = anon_sym_VAR, + [anon_sym_VAR_TEMP] = anon_sym_VAR_TEMP, + [anon_sym_CONSTANT] = anon_sym_CONSTANT, + [anon_sym_RETAIN] = anon_sym_RETAIN, + [anon_sym_NON_RETAIN] = anon_sym_NON_RETAIN, + [anon_sym_VAR_CONSTANT] = anon_sym_VAR_CONSTANT, + [anon_sym_VAR_RETAIN] = anon_sym_VAR_RETAIN, + [anon_sym_VAR_NON_RETAIN] = anon_sym_VAR_NON_RETAIN, + [anon_sym_END_VAR] = anon_sym_END_VAR, + [anon_sym_BOOL] = anon_sym_BOOL, + [anon_sym_Bool] = anon_sym_Bool, + [anon_sym_INT] = anon_sym_INT, + [anon_sym_Int] = anon_sym_Int, + [anon_sym_int] = anon_sym_int, + [anon_sym_DINT] = anon_sym_DINT, + [anon_sym_DInt] = anon_sym_DInt, + [anon_sym_dint] = anon_sym_dint, + [anon_sym_SINT] = anon_sym_SINT, + [anon_sym_SInt] = anon_sym_SInt, + [anon_sym_sint] = anon_sym_sint, + [anon_sym_USINT] = anon_sym_USINT, + [anon_sym_USInt] = anon_sym_USInt, + [anon_sym_usint] = anon_sym_usint, + [anon_sym_UINT] = anon_sym_UINT, + [anon_sym_UInt] = anon_sym_UInt, + [anon_sym_uint] = anon_sym_uint, + [anon_sym_WORD] = anon_sym_WORD, + [anon_sym_Word] = anon_sym_Word, + [anon_sym_word] = anon_sym_word, + [anon_sym_DWORD] = anon_sym_DWORD, + [anon_sym_DWord] = anon_sym_DWord, + [anon_sym_dword] = anon_sym_dword, + [anon_sym_BYTE] = anon_sym_BYTE, + [anon_sym_Byte] = anon_sym_Byte, + [anon_sym_byte] = anon_sym_byte, + [anon_sym_REAL] = anon_sym_REAL, + [anon_sym_Real] = anon_sym_Real, + [anon_sym_real] = anon_sym_real, + [anon_sym_LREAL] = anon_sym_LREAL, + [anon_sym_LReal] = anon_sym_LReal, + [anon_sym_lreal] = anon_sym_lreal, + [anon_sym_TIME] = anon_sym_TIME, + [anon_sym_Time] = anon_sym_Time, + [anon_sym_time] = anon_sym_time, + [anon_sym_TOD] = anon_sym_TOD, + [anon_sym_Tod] = anon_sym_Tod, + [anon_sym_tod] = anon_sym_tod, + [anon_sym_DT] = anon_sym_DT, + [anon_sym_Dt] = anon_sym_Dt, + [anon_sym_dt] = anon_sym_dt, + [anon_sym_String] = anon_sym_String, + [anon_sym_STRING] = anon_sym_STRING, + [anon_sym_string] = anon_sym_string, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [anon_sym_WString] = anon_sym_WString, + [anon_sym_WSTRING] = anon_sym_WSTRING, + [anon_sym_wstring] = anon_sym_wstring, + [anon_sym_Char] = anon_sym_Char, + [anon_sym_CHAR] = anon_sym_CHAR, + [anon_sym_char] = anon_sym_char, + [anon_sym_WChar] = anon_sym_WChar, + [anon_sym_WCHAR] = anon_sym_WCHAR, + [anon_sym_wchar] = anon_sym_wchar, + [anon_sym_ARRAY] = anon_sym_ARRAY, + [anon_sym_DOT_DOT] = anon_sym_DOT_DOT, + [anon_sym_OF] = anon_sym_OF, + [anon_sym_POUND] = anon_sym_POUND, + [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_IF] = anon_sym_IF, + [anon_sym_THEN] = anon_sym_THEN, + [anon_sym_END_IF] = anon_sym_END_IF, + [anon_sym_ELSIF] = anon_sym_ELSIF, + [anon_sym_ELSE] = anon_sym_ELSE, + [anon_sym_CASE] = anon_sym_CASE, + [anon_sym_END_CASE] = anon_sym_END_CASE, + [anon_sym_FOR] = anon_sym_FOR, + [anon_sym_TO] = anon_sym_TO, + [anon_sym_BY] = anon_sym_BY, + [anon_sym_DO] = anon_sym_DO, + [anon_sym_END_FOR] = anon_sym_END_FOR, + [anon_sym_WHILE] = anon_sym_WHILE, + [anon_sym_END_WHILE] = anon_sym_END_WHILE, + [anon_sym_REPEAT] = anon_sym_REPEAT, + [anon_sym_UNTIL] = anon_sym_UNTIL, + [anon_sym_END_REPEAT] = anon_sym_END_REPEAT, + [anon_sym_REGION] = anon_sym_REGION, + [anon_sym_END_REGION] = anon_sym_END_REGION, + [anon_sym_SLASH] = anon_sym_SLASH, + [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_EQ_GT] = anon_sym_EQ_GT, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_NOT] = anon_sym_NOT, + [anon_sym_PLUS] = anon_sym_PLUS, + [anon_sym_OR] = anon_sym_OR, + [anon_sym_XOR] = anon_sym_XOR, + [anon_sym_AND] = anon_sym_AND, + [anon_sym_LT_GT] = anon_sym_LT_GT, + [anon_sym_LT] = anon_sym_LT, + [anon_sym_GT] = anon_sym_GT, + [anon_sym_LT_EQ] = anon_sym_LT_EQ, + [anon_sym_GT_EQ] = anon_sym_GT_EQ, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_MOD] = anon_sym_MOD, + [sym_number] = sym_number, + [sym_hex_number] = sym_hex_number, + [sym_time_value] = sym_time_value, + [anon_sym_SQUOTE] = anon_sym_SQUOTE, + [aux_sym_string_token1] = aux_sym_string_token1, + [anon_sym_SQUOTE_SQUOTE] = anon_sym_SQUOTE_SQUOTE, + [anon_sym_DQUOTE] = anon_sym_DQUOTE, + [aux_sym_string_token2] = aux_sym_string_token2, + [anon_sym_DQUOTE_DQUOTE] = anon_sym_DQUOTE_DQUOTE, + [sym_identifier] = sym_identifier, + [sym_line_comment] = sym_line_comment, + [sym_block_comment] = sym_block_comment, + [sym_c_style_comment] = sym_c_style_comment, + [sym_exit_statement] = sym_exit_statement, + [sym_continue_statement] = sym_continue_statement, + [sym_source_file] = sym_source_file, + [sym_organization_block] = sym_organization_block, + [sym_function_block] = sym_function_block, + [sym_function] = sym_function, + [sym_attribute_list] = sym_attribute_list, + [sym_attribute] = sym_attribute, + [sym_attribute_value] = sym_attribute_value, + [sym_var_declaration] = sym_var_declaration, + [sym_var_temp_declaration] = sym_var_temp_declaration, + [sym_var_constant_declaration] = sym_var_constant_declaration, + [sym_var_retain_declaration] = sym_var_retain_declaration, + [sym_var_non_retain_declaration] = sym_var_non_retain_declaration, + [sym_var_item] = sym_var_item, + [sym_type] = sym_type, + [sym_statement] = sym_statement, + [sym_empty_statement] = sym_empty_statement, + [sym_assignment] = sym_assignment, + [sym_lvalue] = sym_lvalue, + [sym_function_name] = sym_function_name, + [sym_prefixed_identifier] = sym_prefixed_identifier, + [sym_field_access] = sym_field_access, + [sym_array_access] = sym_array_access, + [sym_if_statement] = sym_if_statement, + [sym_elsif_clause] = sym_elsif_clause, + [sym_else_clause] = sym_else_clause, + [sym_case_statement] = sym_case_statement, + [sym_case_item] = sym_case_item, + [sym_range] = sym_range, + [sym_for_statement] = sym_for_statement, + [sym_while_statement] = sym_while_statement, + [sym_repeat_statement] = sym_repeat_statement, + [sym_region_statement] = sym_region_statement, + [sym_region_name] = sym_region_name, + [sym_function_call] = sym_function_call, + [sym_parameter_list] = sym_parameter_list, + [sym_parameter] = sym_parameter, + [sym_expression] = sym_expression, + [sym_unary_expression] = sym_unary_expression, + [sym_binary_expression] = sym_binary_expression, + [sym_string] = sym_string, + [aux_sym_source_file_repeat1] = aux_sym_source_file_repeat1, + [aux_sym_organization_block_repeat1] = aux_sym_organization_block_repeat1, + [aux_sym_organization_block_repeat2] = aux_sym_organization_block_repeat2, + [aux_sym_function_repeat1] = aux_sym_function_repeat1, + [aux_sym_attribute_list_repeat1] = aux_sym_attribute_list_repeat1, + [aux_sym_var_declaration_repeat1] = aux_sym_var_declaration_repeat1, + [aux_sym_if_statement_repeat1] = aux_sym_if_statement_repeat1, + [aux_sym_case_statement_repeat1] = aux_sym_case_statement_repeat1, + [aux_sym_region_name_repeat1] = aux_sym_region_name_repeat1, + [aux_sym_parameter_list_repeat1] = aux_sym_parameter_list_repeat1, + [aux_sym_string_repeat1] = aux_sym_string_repeat1, + [aux_sym_string_repeat2] = aux_sym_string_repeat2, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [anon_sym_ORGANIZATION_BLOCK] = { + .visible = true, + .named = false, + }, + [anon_sym_TITLE] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_VERSION] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_BEGIN] = { + .visible = true, + .named = false, + }, + [anon_sym_END_ORGANIZATION_BLOCK] = { + .visible = true, + .named = false, + }, + [anon_sym_FUNCTION_BLOCK] = { + .visible = true, + .named = false, + }, + [anon_sym_END_FUNCTION_BLOCK] = { + .visible = true, + .named = false, + }, + [anon_sym_FUNCTION] = { + .visible = true, + .named = false, + }, + [anon_sym_END_FUNCTION] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_TRUE] = { + .visible = true, + .named = false, + }, + [anon_sym_FALSE] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_INPUT] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_OUTPUT] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_IN_OUT] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_TEMP] = { + .visible = true, + .named = false, + }, + [anon_sym_CONSTANT] = { + .visible = true, + .named = false, + }, + [anon_sym_RETAIN] = { + .visible = true, + .named = false, + }, + [anon_sym_NON_RETAIN] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_CONSTANT] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_RETAIN] = { + .visible = true, + .named = false, + }, + [anon_sym_VAR_NON_RETAIN] = { + .visible = true, + .named = false, + }, + [anon_sym_END_VAR] = { + .visible = true, + .named = false, + }, + [anon_sym_BOOL] = { + .visible = true, + .named = false, + }, + [anon_sym_Bool] = { + .visible = true, + .named = false, + }, + [anon_sym_INT] = { + .visible = true, + .named = false, + }, + [anon_sym_Int] = { + .visible = true, + .named = false, + }, + [anon_sym_int] = { + .visible = true, + .named = false, + }, + [anon_sym_DINT] = { + .visible = true, + .named = false, + }, + [anon_sym_DInt] = { + .visible = true, + .named = false, + }, + [anon_sym_dint] = { + .visible = true, + .named = false, + }, + [anon_sym_SINT] = { + .visible = true, + .named = false, + }, + [anon_sym_SInt] = { + .visible = true, + .named = false, + }, + [anon_sym_sint] = { + .visible = true, + .named = false, + }, + [anon_sym_USINT] = { + .visible = true, + .named = false, + }, + [anon_sym_USInt] = { + .visible = true, + .named = false, + }, + [anon_sym_usint] = { + .visible = true, + .named = false, + }, + [anon_sym_UINT] = { + .visible = true, + .named = false, + }, + [anon_sym_UInt] = { + .visible = true, + .named = false, + }, + [anon_sym_uint] = { + .visible = true, + .named = false, + }, + [anon_sym_WORD] = { + .visible = true, + .named = false, + }, + [anon_sym_Word] = { + .visible = true, + .named = false, + }, + [anon_sym_word] = { + .visible = true, + .named = false, + }, + [anon_sym_DWORD] = { + .visible = true, + .named = false, + }, + [anon_sym_DWord] = { + .visible = true, + .named = false, + }, + [anon_sym_dword] = { + .visible = true, + .named = false, + }, + [anon_sym_BYTE] = { + .visible = true, + .named = false, + }, + [anon_sym_Byte] = { + .visible = true, + .named = false, + }, + [anon_sym_byte] = { + .visible = true, + .named = false, + }, + [anon_sym_REAL] = { + .visible = true, + .named = false, + }, + [anon_sym_Real] = { + .visible = true, + .named = false, + }, + [anon_sym_real] = { + .visible = true, + .named = false, + }, + [anon_sym_LREAL] = { + .visible = true, + .named = false, + }, + [anon_sym_LReal] = { + .visible = true, + .named = false, + }, + [anon_sym_lreal] = { + .visible = true, + .named = false, + }, + [anon_sym_TIME] = { + .visible = true, + .named = false, + }, + [anon_sym_Time] = { + .visible = true, + .named = false, + }, + [anon_sym_time] = { + .visible = true, + .named = false, + }, + [anon_sym_TOD] = { + .visible = true, + .named = false, + }, + [anon_sym_Tod] = { + .visible = true, + .named = false, + }, + [anon_sym_tod] = { + .visible = true, + .named = false, + }, + [anon_sym_DT] = { + .visible = true, + .named = false, + }, + [anon_sym_Dt] = { + .visible = true, + .named = false, + }, + [anon_sym_dt] = { + .visible = true, + .named = false, + }, + [anon_sym_String] = { + .visible = true, + .named = false, + }, + [anon_sym_STRING] = { + .visible = true, + .named = false, + }, + [anon_sym_string] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_WString] = { + .visible = true, + .named = false, + }, + [anon_sym_WSTRING] = { + .visible = true, + .named = false, + }, + [anon_sym_wstring] = { + .visible = true, + .named = false, + }, + [anon_sym_Char] = { + .visible = true, + .named = false, + }, + [anon_sym_CHAR] = { + .visible = true, + .named = false, + }, + [anon_sym_char] = { + .visible = true, + .named = false, + }, + [anon_sym_WChar] = { + .visible = true, + .named = false, + }, + [anon_sym_WCHAR] = { + .visible = true, + .named = false, + }, + [anon_sym_wchar] = { + .visible = true, + .named = false, + }, + [anon_sym_ARRAY] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_OF] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_IF] = { + .visible = true, + .named = false, + }, + [anon_sym_THEN] = { + .visible = true, + .named = false, + }, + [anon_sym_END_IF] = { + .visible = true, + .named = false, + }, + [anon_sym_ELSIF] = { + .visible = true, + .named = false, + }, + [anon_sym_ELSE] = { + .visible = true, + .named = false, + }, + [anon_sym_CASE] = { + .visible = true, + .named = false, + }, + [anon_sym_END_CASE] = { + .visible = true, + .named = false, + }, + [anon_sym_FOR] = { + .visible = true, + .named = false, + }, + [anon_sym_TO] = { + .visible = true, + .named = false, + }, + [anon_sym_BY] = { + .visible = true, + .named = false, + }, + [anon_sym_DO] = { + .visible = true, + .named = false, + }, + [anon_sym_END_FOR] = { + .visible = true, + .named = false, + }, + [anon_sym_WHILE] = { + .visible = true, + .named = false, + }, + [anon_sym_END_WHILE] = { + .visible = true, + .named = false, + }, + [anon_sym_REPEAT] = { + .visible = true, + .named = false, + }, + [anon_sym_UNTIL] = { + .visible = true, + .named = false, + }, + [anon_sym_END_REPEAT] = { + .visible = true, + .named = false, + }, + [anon_sym_REGION] = { + .visible = true, + .named = false, + }, + [anon_sym_END_REGION] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_NOT] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_OR] = { + .visible = true, + .named = false, + }, + [anon_sym_XOR] = { + .visible = true, + .named = false, + }, + [anon_sym_AND] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_MOD] = { + .visible = true, + .named = false, + }, + [sym_number] = { + .visible = true, + .named = true, + }, + [sym_hex_number] = { + .visible = true, + .named = true, + }, + [sym_time_value] = { + .visible = true, + .named = true, + }, + [anon_sym_SQUOTE] = { + .visible = true, + .named = false, + }, + [aux_sym_string_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_SQUOTE_SQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_DQUOTE] = { + .visible = true, + .named = false, + }, + [aux_sym_string_token2] = { + .visible = false, + .named = false, + }, + [anon_sym_DQUOTE_DQUOTE] = { + .visible = true, + .named = false, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [sym_line_comment] = { + .visible = true, + .named = true, + }, + [sym_block_comment] = { + .visible = true, + .named = true, + }, + [sym_c_style_comment] = { + .visible = true, + .named = true, + }, + [sym_exit_statement] = { + .visible = true, + .named = true, + }, + [sym_continue_statement] = { + .visible = true, + .named = true, + }, + [sym_source_file] = { + .visible = true, + .named = true, + }, + [sym_organization_block] = { + .visible = true, + .named = true, + }, + [sym_function_block] = { + .visible = true, + .named = true, + }, + [sym_function] = { + .visible = true, + .named = true, + }, + [sym_attribute_list] = { + .visible = true, + .named = true, + }, + [sym_attribute] = { + .visible = true, + .named = true, + }, + [sym_attribute_value] = { + .visible = true, + .named = true, + }, + [sym_var_declaration] = { + .visible = true, + .named = true, + }, + [sym_var_temp_declaration] = { + .visible = true, + .named = true, + }, + [sym_var_constant_declaration] = { + .visible = true, + .named = true, + }, + [sym_var_retain_declaration] = { + .visible = true, + .named = true, + }, + [sym_var_non_retain_declaration] = { + .visible = true, + .named = true, + }, + [sym_var_item] = { + .visible = true, + .named = true, + }, + [sym_type] = { + .visible = true, + .named = true, + }, + [sym_statement] = { + .visible = true, + .named = true, + }, + [sym_empty_statement] = { + .visible = true, + .named = true, + }, + [sym_assignment] = { + .visible = true, + .named = true, + }, + [sym_lvalue] = { + .visible = true, + .named = true, + }, + [sym_function_name] = { + .visible = true, + .named = true, + }, + [sym_prefixed_identifier] = { + .visible = true, + .named = true, + }, + [sym_field_access] = { + .visible = true, + .named = true, + }, + [sym_array_access] = { + .visible = true, + .named = true, + }, + [sym_if_statement] = { + .visible = true, + .named = true, + }, + [sym_elsif_clause] = { + .visible = true, + .named = true, + }, + [sym_else_clause] = { + .visible = true, + .named = true, + }, + [sym_case_statement] = { + .visible = true, + .named = true, + }, + [sym_case_item] = { + .visible = true, + .named = true, + }, + [sym_range] = { + .visible = true, + .named = true, + }, + [sym_for_statement] = { + .visible = true, + .named = true, + }, + [sym_while_statement] = { + .visible = true, + .named = true, + }, + [sym_repeat_statement] = { + .visible = true, + .named = true, + }, + [sym_region_statement] = { + .visible = true, + .named = true, + }, + [sym_region_name] = { + .visible = true, + .named = true, + }, + [sym_function_call] = { + .visible = true, + .named = true, + }, + [sym_parameter_list] = { + .visible = true, + .named = true, + }, + [sym_parameter] = { + .visible = true, + .named = true, + }, + [sym_expression] = { + .visible = true, + .named = true, + }, + [sym_unary_expression] = { + .visible = true, + .named = true, + }, + [sym_binary_expression] = { + .visible = true, + .named = true, + }, + [sym_string] = { + .visible = true, + .named = true, + }, + [aux_sym_source_file_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_organization_block_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_organization_block_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_function_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_attribute_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_var_declaration_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_if_statement_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_case_statement_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_region_name_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_parameter_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_string_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_string_repeat2] = { + .visible = false, + .named = false, + }, +}; + +enum ts_field_identifiers { + field_name = 1, + field_target = 2, + field_type = 3, + field_value = 4, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_name] = "name", + [field_target] = "target", + [field_type] = "type", + [field_value] = "value", +}; + +static const TSMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [1] = {.index = 0, .length = 1}, + [2] = {.index = 1, .length = 2}, + [3] = {.index = 3, .length = 2}, + [4] = {.index = 5, .length = 2}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_name, 1}, + [1] = + {field_target, 0}, + {field_value, 2}, + [3] = + {field_name, 0}, + {field_type, 2}, + [5] = + {field_name, 0}, + {field_type, 3}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 3, + [7] = 7, + [8] = 8, + [9] = 9, + [10] = 9, + [11] = 9, + [12] = 12, + [13] = 12, + [14] = 9, + [15] = 12, + [16] = 9, + [17] = 12, + [18] = 9, + [19] = 12, + [20] = 9, + [21] = 12, + [22] = 9, + [23] = 12, + [24] = 12, + [25] = 12, + [26] = 9, + [27] = 12, + [28] = 9, + [29] = 12, + [30] = 9, + [31] = 9, + [32] = 12, + [33] = 33, + [34] = 33, + [35] = 35, + [36] = 36, + [37] = 37, + [38] = 38, + [39] = 39, + [40] = 40, + [41] = 41, + [42] = 42, + [43] = 43, + [44] = 44, + [45] = 45, + [46] = 46, + [47] = 47, + [48] = 48, + [49] = 49, + [50] = 50, + [51] = 51, + [52] = 52, + [53] = 53, + [54] = 54, + [55] = 55, + [56] = 56, + [57] = 57, + [58] = 58, + [59] = 59, + [60] = 60, + [61] = 61, + [62] = 62, + [63] = 63, + [64] = 64, + [65] = 65, + [66] = 66, + [67] = 67, + [68] = 68, + [69] = 69, + [70] = 70, + [71] = 71, + [72] = 72, + [73] = 73, + [74] = 74, + [75] = 75, + [76] = 76, + [77] = 77, + [78] = 78, + [79] = 79, + [80] = 80, + [81] = 81, + [82] = 82, + [83] = 83, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 89, + [90] = 90, + [91] = 33, + [92] = 92, + [93] = 41, + [94] = 33, + [95] = 33, + [96] = 33, + [97] = 97, + [98] = 33, + [99] = 33, + [100] = 33, + [101] = 33, + [102] = 102, + [103] = 103, + [104] = 103, + [105] = 39, + [106] = 33, + [107] = 107, + [108] = 55, + [109] = 62, + [110] = 69, + [111] = 77, + [112] = 102, + [113] = 103, + [114] = 114, + [115] = 39, + [116] = 107, + [117] = 55, + [118] = 118, + [119] = 69, + [120] = 77, + [121] = 102, + [122] = 103, + [123] = 39, + [124] = 107, + [125] = 55, + [126] = 62, + [127] = 69, + [128] = 77, + [129] = 102, + [130] = 103, + [131] = 39, + [132] = 132, + [133] = 107, + [134] = 55, + [135] = 62, + [136] = 69, + [137] = 77, + [138] = 102, + [139] = 139, + [140] = 103, + [141] = 39, + [142] = 142, + [143] = 107, + [144] = 55, + [145] = 62, + [146] = 69, + [147] = 77, + [148] = 102, + [149] = 149, + [150] = 103, + [151] = 39, + [152] = 152, + [153] = 107, + [154] = 55, + [155] = 62, + [156] = 69, + [157] = 77, + [158] = 102, + [159] = 159, + [160] = 103, + [161] = 39, + [162] = 162, + [163] = 107, + [164] = 55, + [165] = 62, + [166] = 69, + [167] = 77, + [168] = 102, + [169] = 92, + [170] = 103, + [171] = 39, + [172] = 102, + [173] = 107, + [174] = 55, + [175] = 62, + [176] = 69, + [177] = 77, + [178] = 102, + [179] = 107, + [180] = 103, + [181] = 39, + [182] = 107, + [183] = 55, + [184] = 62, + [185] = 69, + [186] = 77, + [187] = 102, + [188] = 103, + [189] = 39, + [190] = 190, + [191] = 107, + [192] = 55, + [193] = 62, + [194] = 69, + [195] = 77, + [196] = 102, + [197] = 197, + [198] = 103, + [199] = 39, + [200] = 200, + [201] = 107, + [202] = 55, + [203] = 62, + [204] = 69, + [205] = 77, + [206] = 206, + [207] = 114, + [208] = 162, + [209] = 114, + [210] = 162, + [211] = 114, + [212] = 162, + [213] = 114, + [214] = 162, + [215] = 114, + [216] = 162, + [217] = 114, + [218] = 162, + [219] = 114, + [220] = 162, + [221] = 114, + [222] = 162, + [223] = 114, + [224] = 162, + [225] = 114, + [226] = 162, + [227] = 114, + [228] = 162, + [229] = 62, + [230] = 230, + [231] = 231, + [232] = 232, + [233] = 233, + [234] = 234, + [235] = 232, + [236] = 236, + [237] = 233, + [238] = 232, + [239] = 233, + [240] = 240, + [241] = 234, + [242] = 240, + [243] = 240, + [244] = 244, + [245] = 245, + [246] = 234, + [247] = 247, + [248] = 248, + [249] = 232, + [250] = 233, + [251] = 251, + [252] = 233, + [253] = 233, + [254] = 232, + [255] = 233, + [256] = 232, + [257] = 232, + [258] = 232, + [259] = 233, + [260] = 233, + [261] = 232, + [262] = 232, + [263] = 233, + [264] = 233, + [265] = 232, + [266] = 230, + [267] = 232, + [268] = 233, + [269] = 231, + [270] = 230, + [271] = 240, + [272] = 230, + [273] = 240, + [274] = 234, + [275] = 240, + [276] = 234, + [277] = 234, + [278] = 231, + [279] = 240, + [280] = 231, + [281] = 240, + [282] = 240, + [283] = 234, + [284] = 234, + [285] = 240, + [286] = 240, + [287] = 234, + [288] = 234, + [289] = 234, + [290] = 234, + [291] = 240, + [292] = 292, + [293] = 293, + [294] = 294, + [295] = 295, + [296] = 296, + [297] = 297, + [298] = 298, + [299] = 299, + [300] = 300, + [301] = 301, + [302] = 302, + [303] = 303, + [304] = 304, + [305] = 305, + [306] = 306, + [307] = 307, + [308] = 308, + [309] = 309, + [310] = 310, + [311] = 311, + [312] = 312, + [313] = 313, + [314] = 314, + [315] = 315, + [316] = 316, + [317] = 317, + [318] = 318, + [319] = 319, + [320] = 320, + [321] = 321, + [322] = 322, + [323] = 323, + [324] = 324, + [325] = 325, + [326] = 325, + [327] = 327, + [328] = 328, + [329] = 329, + [330] = 330, + [331] = 331, + [332] = 332, + [333] = 333, + [334] = 334, + [335] = 335, + [336] = 336, + [337] = 337, + [338] = 338, + [339] = 339, + [340] = 340, + [341] = 341, + [342] = 342, + [343] = 343, + [344] = 344, + [345] = 345, + [346] = 346, + [347] = 347, + [348] = 348, + [349] = 349, + [350] = 350, + [351] = 351, + [352] = 352, + [353] = 323, + [354] = 354, + [355] = 355, + [356] = 356, + [357] = 357, + [358] = 358, + [359] = 320, + [360] = 360, + [361] = 361, + [362] = 362, + [363] = 363, + [364] = 364, + [365] = 365, + [366] = 366, + [367] = 367, + [368] = 368, + [369] = 369, + [370] = 370, + [371] = 371, + [372] = 372, + [373] = 373, + [374] = 374, + [375] = 375, + [376] = 356, + [377] = 298, + [378] = 299, + [379] = 319, + [380] = 230, + [381] = 322, + [382] = 324, + [383] = 337, + [384] = 231, + [385] = 338, + [386] = 349, + [387] = 230, + [388] = 361, + [389] = 372, + [390] = 300, + [391] = 231, + [392] = 331, + [393] = 293, + [394] = 345, + [395] = 332, + [396] = 230, + [397] = 347, + [398] = 351, + [399] = 350, + [400] = 231, + [401] = 329, + [402] = 344, + [403] = 345, + [404] = 348, + [405] = 350, + [406] = 230, + [407] = 354, + [408] = 373, + [409] = 336, + [410] = 295, + [411] = 296, + [412] = 298, + [413] = 299, + [414] = 319, + [415] = 322, + [416] = 324, + [417] = 337, + [418] = 338, + [419] = 349, + [420] = 361, + [421] = 372, + [422] = 300, + [423] = 331, + [424] = 348, + [425] = 347, + [426] = 351, + [427] = 366, + [428] = 230, + [429] = 366, + [430] = 367, + [431] = 371, + [432] = 292, + [433] = 367, + [434] = 371, + [435] = 292, + [436] = 231, + [437] = 320, + [438] = 314, + [439] = 317, + [440] = 318, + [441] = 354, + [442] = 323, + [443] = 325, + [444] = 312, + [445] = 373, + [446] = 231, + [447] = 360, + [448] = 320, + [449] = 314, + [450] = 317, + [451] = 318, + [452] = 230, + [453] = 336, + [454] = 230, + [455] = 323, + [456] = 325, + [457] = 231, + [458] = 231, + [459] = 312, + [460] = 295, + [461] = 293, + [462] = 356, + [463] = 360, + [464] = 230, + [465] = 296, + [466] = 230, + [467] = 231, + [468] = 231, + [469] = 329, + [470] = 344, + [471] = 332, + [472] = 348, + [473] = 312, + [474] = 319, + [475] = 322, + [476] = 324, + [477] = 337, + [478] = 338, + [479] = 360, + [480] = 349, + [481] = 361, + [482] = 372, + [483] = 300, + [484] = 293, + [485] = 356, + [486] = 329, + [487] = 344, + [488] = 345, + [489] = 348, + [490] = 350, + [491] = 320, + [492] = 356, + [493] = 373, + [494] = 336, + [495] = 295, + [496] = 296, + [497] = 298, + [498] = 299, + [499] = 319, + [500] = 322, + [501] = 324, + [502] = 329, + [503] = 337, + [504] = 338, + [505] = 349, + [506] = 361, + [507] = 372, + [508] = 300, + [509] = 293, + [510] = 356, + [511] = 344, + [512] = 331, + [513] = 332, + [514] = 347, + [515] = 351, + [516] = 345, + [517] = 348, + [518] = 350, + [519] = 366, + [520] = 367, + [521] = 371, + [522] = 292, + [523] = 323, + [524] = 354, + [525] = 373, + [526] = 320, + [527] = 314, + [528] = 317, + [529] = 318, + [530] = 329, + [531] = 344, + [532] = 345, + [533] = 348, + [534] = 350, + [535] = 336, + [536] = 323, + [537] = 354, + [538] = 373, + [539] = 336, + [540] = 295, + [541] = 296, + [542] = 298, + [543] = 299, + [544] = 319, + [545] = 322, + [546] = 324, + [547] = 325, + [548] = 337, + [549] = 338, + [550] = 349, + [551] = 361, + [552] = 372, + [553] = 300, + [554] = 293, + [555] = 356, + [556] = 312, + [557] = 331, + [558] = 332, + [559] = 347, + [560] = 351, + [561] = 295, + [562] = 296, + [563] = 360, + [564] = 366, + [565] = 367, + [566] = 371, + [567] = 292, + [568] = 298, + [569] = 299, + [570] = 319, + [571] = 322, + [572] = 320, + [573] = 314, + [574] = 317, + [575] = 318, + [576] = 329, + [577] = 344, + [578] = 345, + [579] = 324, + [580] = 350, + [581] = 325, + [582] = 323, + [583] = 354, + [584] = 373, + [585] = 336, + [586] = 295, + [587] = 296, + [588] = 298, + [589] = 299, + [590] = 319, + [591] = 322, + [592] = 324, + [593] = 325, + [594] = 337, + [595] = 338, + [596] = 349, + [597] = 361, + [598] = 372, + [599] = 300, + [600] = 337, + [601] = 338, + [602] = 312, + [603] = 331, + [604] = 332, + [605] = 347, + [606] = 351, + [607] = 349, + [608] = 361, + [609] = 360, + [610] = 366, + [611] = 367, + [612] = 371, + [613] = 292, + [614] = 372, + [615] = 300, + [616] = 293, + [617] = 356, + [618] = 320, + [619] = 314, + [620] = 317, + [621] = 318, + [622] = 331, + [623] = 332, + [624] = 347, + [625] = 351, + [626] = 323, + [627] = 366, + [628] = 367, + [629] = 371, + [630] = 292, + [631] = 320, + [632] = 314, + [633] = 325, + [634] = 317, + [635] = 318, + [636] = 329, + [637] = 344, + [638] = 345, + [639] = 348, + [640] = 293, + [641] = 356, + [642] = 312, + [643] = 350, + [644] = 323, + [645] = 354, + [646] = 373, + [647] = 336, + [648] = 360, + [649] = 295, + [650] = 296, + [651] = 298, + [652] = 299, + [653] = 319, + [654] = 322, + [655] = 324, + [656] = 325, + [657] = 337, + [658] = 338, + [659] = 349, + [660] = 329, + [661] = 344, + [662] = 345, + [663] = 348, + [664] = 350, + [665] = 361, + [666] = 372, + [667] = 354, + [668] = 373, + [669] = 336, + [670] = 295, + [671] = 296, + [672] = 298, + [673] = 299, + [674] = 319, + [675] = 322, + [676] = 324, + [677] = 300, + [678] = 337, + [679] = 338, + [680] = 349, + [681] = 361, + [682] = 372, + [683] = 300, + [684] = 293, + [685] = 331, + [686] = 332, + [687] = 347, + [688] = 351, + [689] = 356, + [690] = 312, + [691] = 366, + [692] = 367, + [693] = 371, + [694] = 292, + [695] = 331, + [696] = 320, + [697] = 314, + [698] = 317, + [699] = 318, + [700] = 323, + [701] = 325, + [702] = 312, + [703] = 332, + [704] = 360, + [705] = 347, + [706] = 351, + [707] = 360, + [708] = 366, + [709] = 367, + [710] = 371, + [711] = 292, + [712] = 320, + [713] = 314, + [714] = 317, + [715] = 318, + [716] = 329, + [717] = 344, + [718] = 345, + [719] = 348, + [720] = 350, + [721] = 323, + [722] = 354, + [723] = 373, + [724] = 336, + [725] = 295, + [726] = 296, + [727] = 298, + [728] = 299, + [729] = 319, + [730] = 322, + [731] = 324, + [732] = 325, + [733] = 337, + [734] = 338, + [735] = 349, + [736] = 361, + [737] = 372, + [738] = 300, + [739] = 293, + [740] = 356, + [741] = 312, + [742] = 331, + [743] = 332, + [744] = 347, + [745] = 351, + [746] = 293, + [747] = 360, + [748] = 366, + [749] = 367, + [750] = 371, + [751] = 292, + [752] = 356, + [753] = 312, + [754] = 331, + [755] = 332, + [756] = 320, + [757] = 314, + [758] = 317, + [759] = 318, + [760] = 329, + [761] = 344, + [762] = 345, + [763] = 348, + [764] = 350, + [765] = 347, + [766] = 323, + [767] = 354, + [768] = 373, + [769] = 336, + [770] = 295, + [771] = 296, + [772] = 298, + [773] = 299, + [774] = 319, + [775] = 322, + [776] = 324, + [777] = 325, + [778] = 337, + [779] = 338, + [780] = 349, + [781] = 361, + [782] = 372, + [783] = 300, + [784] = 351, + [785] = 312, + [786] = 331, + [787] = 332, + [788] = 347, + [789] = 351, + [790] = 360, + [791] = 366, + [792] = 360, + [793] = 366, + [794] = 367, + [795] = 371, + [796] = 292, + [797] = 367, + [798] = 371, + [799] = 292, + [800] = 320, + [801] = 314, + [802] = 317, + [803] = 318, + [804] = 314, + [805] = 317, + [806] = 318, + [807] = 323, + [808] = 329, + [809] = 344, + [810] = 345, + [811] = 348, + [812] = 350, + [813] = 354, + [814] = 325, + [815] = 373, + [816] = 336, + [817] = 295, + [818] = 296, + [819] = 298, + [820] = 299, + [821] = 293, + [822] = 354, + [823] = 823, + [824] = 824, + [825] = 825, + [826] = 826, + [827] = 827, + [828] = 828, + [829] = 829, + [830] = 830, + [831] = 831, + [832] = 832, + [833] = 830, + [834] = 831, + [835] = 832, + [836] = 830, + [837] = 831, + [838] = 832, + [839] = 830, + [840] = 831, + [841] = 832, + [842] = 830, + [843] = 831, + [844] = 832, + [845] = 845, + [846] = 830, + [847] = 831, + [848] = 832, + [849] = 830, + [850] = 831, + [851] = 832, + [852] = 830, + [853] = 831, + [854] = 832, + [855] = 830, + [856] = 831, + [857] = 832, + [858] = 830, + [859] = 831, + [860] = 832, + [861] = 830, + [862] = 831, + [863] = 832, + [864] = 823, + [865] = 865, + [866] = 866, + [867] = 867, + [868] = 845, + [869] = 823, + [870] = 865, + [871] = 866, + [872] = 866, + [873] = 823, + [874] = 867, + [875] = 845, + [876] = 823, + [877] = 865, + [878] = 866, + [879] = 879, + [880] = 867, + [881] = 845, + [882] = 830, + [883] = 866, + [884] = 867, + [885] = 845, + [886] = 823, + [887] = 865, + [888] = 866, + [889] = 831, + [890] = 867, + [891] = 845, + [892] = 823, + [893] = 865, + [894] = 866, + [895] = 895, + [896] = 896, + [897] = 867, + [898] = 845, + [899] = 823, + [900] = 865, + [901] = 866, + [902] = 902, + [903] = 832, + [904] = 867, + [905] = 845, + [906] = 823, + [907] = 865, + [908] = 866, + [909] = 909, + [910] = 867, + [911] = 867, + [912] = 845, + [913] = 823, + [914] = 865, + [915] = 866, + [916] = 865, + [917] = 867, + [918] = 845, + [919] = 823, + [920] = 865, + [921] = 866, + [922] = 922, + [923] = 923, + [924] = 867, + [925] = 845, + [926] = 823, + [927] = 865, + [928] = 866, + [929] = 929, + [930] = 930, + [931] = 867, + [932] = 845, + [933] = 879, + [934] = 879, + [935] = 879, + [936] = 879, + [937] = 879, + [938] = 879, + [939] = 879, + [940] = 879, + [941] = 879, + [942] = 879, + [943] = 879, + [944] = 865, + [945] = 945, + [946] = 946, + [947] = 947, + [948] = 948, + [949] = 949, + [950] = 950, + [951] = 950, + [952] = 950, + [953] = 950, + [954] = 954, + [955] = 955, + [956] = 950, + [957] = 950, + [958] = 950, + [959] = 950, + [960] = 950, + [961] = 961, + [962] = 962, + [963] = 950, + [964] = 950, + [965] = 950, + [966] = 966, + [967] = 967, + [968] = 968, + [969] = 969, + [970] = 970, + [971] = 968, + [972] = 969, + [973] = 970, + [974] = 968, + [975] = 969, + [976] = 970, + [977] = 968, + [978] = 969, + [979] = 979, + [980] = 970, + [981] = 981, + [982] = 982, + [983] = 968, + [984] = 969, + [985] = 985, + [986] = 970, + [987] = 987, + [988] = 968, + [989] = 969, + [990] = 990, + [991] = 991, + [992] = 970, + [993] = 993, + [994] = 968, + [995] = 969, + [996] = 996, + [997] = 970, + [998] = 966, + [999] = 968, + [1000] = 969, + [1001] = 970, + [1002] = 1002, + [1003] = 1003, + [1004] = 968, + [1005] = 969, + [1006] = 970, + [1007] = 1007, + [1008] = 968, + [1009] = 969, + [1010] = 970, + [1011] = 1011, + [1012] = 1012, + [1013] = 1013, + [1014] = 968, + [1015] = 969, + [1016] = 970, + [1017] = 970, + [1018] = 1018, + [1019] = 1019, + [1020] = 1020, + [1021] = 966, + [1022] = 1018, + [1023] = 1019, + [1024] = 1020, + [1025] = 1025, + [1026] = 1026, + [1027] = 966, + [1028] = 1018, + [1029] = 1019, + [1030] = 1020, + [1031] = 966, + [1032] = 1018, + [1033] = 1019, + [1034] = 1020, + [1035] = 966, + [1036] = 1018, + [1037] = 1019, + [1038] = 1020, + [1039] = 1039, + [1040] = 1018, + [1041] = 1019, + [1042] = 1020, + [1043] = 1043, + [1044] = 966, + [1045] = 1018, + [1046] = 1019, + [1047] = 1020, + [1048] = 1048, + [1049] = 966, + [1050] = 1018, + [1051] = 1019, + [1052] = 1020, + [1053] = 966, + [1054] = 1018, + [1055] = 1019, + [1056] = 1020, + [1057] = 1057, + [1058] = 966, + [1059] = 1018, + [1060] = 1019, + [1061] = 1020, + [1062] = 966, + [1063] = 1018, + [1064] = 1019, + [1065] = 1020, + [1066] = 1066, + [1067] = 966, + [1068] = 968, + [1069] = 1018, + [1070] = 1019, + [1071] = 1020, + [1072] = 969, + [1073] = 1073, + [1074] = 1074, + [1075] = 1011, + [1076] = 1011, + [1077] = 1011, + [1078] = 1011, + [1079] = 1011, + [1080] = 1011, + [1081] = 1011, + [1082] = 1011, + [1083] = 1011, + [1084] = 1011, + [1085] = 1011, + [1086] = 1086, + [1087] = 1087, + [1088] = 1088, + [1089] = 1089, + [1090] = 231, + [1091] = 230, + [1092] = 1092, + [1093] = 1093, + [1094] = 1094, + [1095] = 1095, + [1096] = 1096, + [1097] = 1097, + [1098] = 1098, + [1099] = 1099, + [1100] = 1100, + [1101] = 1101, + [1102] = 1102, + [1103] = 1103, + [1104] = 1104, + [1105] = 1105, + [1106] = 1106, + [1107] = 1107, + [1108] = 1108, + [1109] = 1109, + [1110] = 1110, + [1111] = 1111, + [1112] = 1112, + [1113] = 1113, + [1114] = 1114, + [1115] = 1115, + [1116] = 1116, + [1117] = 1117, + [1118] = 1118, + [1119] = 1119, + [1120] = 1120, + [1121] = 1121, + [1122] = 1122, + [1123] = 1123, + [1124] = 1124, + [1125] = 1124, + [1126] = 1124, + [1127] = 1123, + [1128] = 1124, + [1129] = 1123, + [1130] = 1123, + [1131] = 1123, + [1132] = 1124, + [1133] = 1124, + [1134] = 1123, + [1135] = 1124, + [1136] = 1123, + [1137] = 1118, + [1138] = 1124, + [1139] = 1116, + [1140] = 1124, + [1141] = 1110, + [1142] = 1123, + [1143] = 1123, + [1144] = 1124, + [1145] = 1124, + [1146] = 1124, + [1147] = 1123, + [1148] = 1123, + [1149] = 1123, + [1150] = 360, + [1151] = 351, + [1152] = 347, + [1153] = 331, + [1154] = 1154, + [1155] = 360, + [1156] = 312, + [1157] = 332, + [1158] = 366, + [1159] = 367, + [1160] = 371, + [1161] = 292, + [1162] = 312, + [1163] = 318, + [1164] = 317, + [1165] = 314, + [1166] = 1166, + [1167] = 1167, + [1168] = 1167, + [1169] = 1167, + [1170] = 1167, + [1171] = 1167, + [1172] = 1167, + [1173] = 1167, + [1174] = 1167, + [1175] = 1167, + [1176] = 1167, + [1177] = 1167, + [1178] = 1167, + [1179] = 1179, + [1180] = 1179, + [1181] = 1179, + [1182] = 1179, + [1183] = 1183, + [1184] = 1179, + [1185] = 1179, + [1186] = 1186, + [1187] = 1179, + [1188] = 1179, + [1189] = 1179, + [1190] = 1179, + [1191] = 1179, + [1192] = 1179, + [1193] = 1179, + [1194] = 1194, + [1195] = 1195, + [1196] = 1194, + [1197] = 1195, + [1198] = 1194, + [1199] = 1195, + [1200] = 1195, + [1201] = 1195, + [1202] = 1194, + [1203] = 1195, + [1204] = 1195, + [1205] = 1195, + [1206] = 1194, + [1207] = 1194, + [1208] = 1195, + [1209] = 1194, + [1210] = 1195, + [1211] = 1194, + [1212] = 1194, + [1213] = 1194, + [1214] = 1194, + [1215] = 1195, + [1216] = 1195, + [1217] = 1194, + [1218] = 1218, + [1219] = 1219, + [1220] = 1220, + [1221] = 1221, + [1222] = 1222, + [1223] = 1223, + [1224] = 1224, + [1225] = 1225, + [1226] = 1226, + [1227] = 1227, + [1228] = 1228, + [1229] = 1219, + [1230] = 1230, + [1231] = 1231, + [1232] = 1232, + [1233] = 1233, + [1234] = 1234, + [1235] = 1235, + [1236] = 1223, + [1237] = 1237, + [1238] = 1238, + [1239] = 1239, + [1240] = 1220, + [1241] = 1241, + [1242] = 1242, + [1243] = 1243, + [1244] = 1244, + [1245] = 1221, + [1246] = 1222, + [1247] = 1223, + [1248] = 1224, + [1249] = 1221, + [1250] = 1225, + [1251] = 1222, + [1252] = 1223, + [1253] = 1224, + [1254] = 1225, + [1255] = 1226, + [1256] = 1227, + [1257] = 1228, + [1258] = 1219, + [1259] = 1230, + [1260] = 1231, + [1261] = 1232, + [1262] = 1233, + [1263] = 1234, + [1264] = 1235, + [1265] = 1226, + [1266] = 1237, + [1267] = 1238, + [1268] = 1239, + [1269] = 1220, + [1270] = 1241, + [1271] = 1242, + [1272] = 1227, + [1273] = 1228, + [1274] = 1239, + [1275] = 1230, + [1276] = 1224, + [1277] = 1231, + [1278] = 1232, + [1279] = 1233, + [1280] = 1234, + [1281] = 1235, + [1282] = 1237, + [1283] = 1238, + [1284] = 1221, + [1285] = 1239, + [1286] = 1222, + [1287] = 1223, + [1288] = 1224, + [1289] = 1225, + [1290] = 1226, + [1291] = 1227, + [1292] = 1228, + [1293] = 1219, + [1294] = 1230, + [1295] = 1231, + [1296] = 1232, + [1297] = 1233, + [1298] = 1234, + [1299] = 1235, + [1300] = 1220, + [1301] = 1237, + [1302] = 1238, + [1303] = 1239, + [1304] = 1220, + [1305] = 1241, + [1306] = 1242, + [1307] = 1241, + [1308] = 1242, + [1309] = 1228, + [1310] = 1221, + [1311] = 1222, + [1312] = 1223, + [1313] = 1224, + [1314] = 1225, + [1315] = 1226, + [1316] = 1227, + [1317] = 1228, + [1318] = 1219, + [1319] = 1230, + [1320] = 1231, + [1321] = 1232, + [1322] = 1233, + [1323] = 1234, + [1324] = 1235, + [1325] = 1219, + [1326] = 1237, + [1327] = 1238, + [1328] = 1239, + [1329] = 1220, + [1330] = 1241, + [1331] = 1242, + [1332] = 1238, + [1333] = 1230, + [1334] = 1221, + [1335] = 1239, + [1336] = 1222, + [1337] = 1223, + [1338] = 1224, + [1339] = 1225, + [1340] = 1226, + [1341] = 1227, + [1342] = 1228, + [1343] = 1219, + [1344] = 1230, + [1345] = 1231, + [1346] = 1232, + [1347] = 1233, + [1348] = 1234, + [1349] = 1235, + [1350] = 1350, + [1351] = 1237, + [1352] = 1238, + [1353] = 1239, + [1354] = 1220, + [1355] = 1241, + [1356] = 1242, + [1357] = 1221, + [1358] = 1221, + [1359] = 1222, + [1360] = 1231, + [1361] = 1223, + [1362] = 1224, + [1363] = 1225, + [1364] = 1226, + [1365] = 1227, + [1366] = 1366, + [1367] = 1225, + [1368] = 1220, + [1369] = 1221, + [1370] = 1228, + [1371] = 1222, + [1372] = 1223, + [1373] = 1224, + [1374] = 1225, + [1375] = 1226, + [1376] = 1227, + [1377] = 1228, + [1378] = 1219, + [1379] = 1230, + [1380] = 1231, + [1381] = 1232, + [1382] = 1233, + [1383] = 1234, + [1384] = 1235, + [1385] = 1237, + [1386] = 1238, + [1387] = 1239, + [1388] = 1220, + [1389] = 1241, + [1390] = 1242, + [1391] = 1221, + [1392] = 1226, + [1393] = 1227, + [1394] = 1228, + [1395] = 1237, + [1396] = 1238, + [1397] = 1219, + [1398] = 1398, + [1399] = 1399, + [1400] = 1230, + [1401] = 1231, + [1402] = 1232, + [1403] = 1232, + [1404] = 1404, + [1405] = 1241, + [1406] = 1233, + [1407] = 1234, + [1408] = 1238, + [1409] = 1399, + [1410] = 1235, + [1411] = 1237, + [1412] = 1238, + [1413] = 1239, + [1414] = 1220, + [1415] = 1241, + [1416] = 1242, + [1417] = 1398, + [1418] = 1399, + [1419] = 1222, + [1420] = 1242, + [1421] = 1222, + [1422] = 1223, + [1423] = 1242, + [1424] = 1224, + [1425] = 1398, + [1426] = 1399, + [1427] = 1225, + [1428] = 1226, + [1429] = 1227, + [1430] = 1243, + [1431] = 1431, + [1432] = 1228, + [1433] = 1219, + [1434] = 1398, + [1435] = 1399, + [1436] = 1230, + [1437] = 1233, + [1438] = 1398, + [1439] = 1399, + [1440] = 1440, + [1441] = 1231, + [1442] = 1221, + [1443] = 1232, + [1444] = 1234, + [1445] = 1222, + [1446] = 1223, + [1447] = 1398, + [1448] = 1399, + [1449] = 1224, + [1450] = 1225, + [1451] = 1226, + [1452] = 1235, + [1453] = 1227, + [1454] = 1228, + [1455] = 1219, + [1456] = 1398, + [1457] = 1399, + [1458] = 1230, + [1459] = 1231, + [1460] = 1232, + [1461] = 1233, + [1462] = 1234, + [1463] = 1398, + [1464] = 1399, + [1465] = 1235, + [1466] = 1233, + [1467] = 1237, + [1468] = 1238, + [1469] = 1239, + [1470] = 1221, + [1471] = 1220, + [1472] = 1241, + [1473] = 1398, + [1474] = 1399, + [1475] = 1242, + [1476] = 1234, + [1477] = 1235, + [1478] = 1226, + [1479] = 1479, + [1480] = 1237, + [1481] = 1398, + [1482] = 1399, + [1483] = 1238, + [1484] = 1239, + [1485] = 1220, + [1486] = 1241, + [1487] = 1242, + [1488] = 1227, + [1489] = 1398, + [1490] = 1350, + [1491] = 1491, + [1492] = 1492, + [1493] = 1237, + [1494] = 1221, + [1495] = 1222, + [1496] = 1496, + [1497] = 1223, + [1498] = 1224, + [1499] = 1499, + [1500] = 1225, + [1501] = 1226, + [1502] = 1227, + [1503] = 1228, + [1504] = 1219, + [1505] = 1230, + [1506] = 1231, + [1507] = 1232, + [1508] = 1233, + [1509] = 1234, + [1510] = 1235, + [1511] = 1237, + [1512] = 1238, + [1513] = 1239, + [1514] = 1220, + [1515] = 1515, + [1516] = 1241, + [1517] = 1242, + [1518] = 1518, + [1519] = 1519, + [1520] = 1221, + [1521] = 1222, + [1522] = 1223, + [1523] = 1224, + [1524] = 1225, + [1525] = 1226, + [1526] = 1227, + [1527] = 1241, + [1528] = 1228, + [1529] = 1219, + [1530] = 1230, + [1531] = 1231, + [1532] = 1232, + [1533] = 1233, + [1534] = 1234, + [1535] = 1235, + [1536] = 1399, + [1537] = 1237, + [1538] = 1398, + [1539] = 1539, + [1540] = 1540, + [1541] = 1539, + [1542] = 1542, + [1543] = 1539, + [1544] = 1539, + [1545] = 1545, + [1546] = 1539, + [1547] = 1547, + [1548] = 1539, + [1549] = 1549, + [1550] = 1539, + [1551] = 1551, + [1552] = 1089, + [1553] = 1539, + [1554] = 1554, + [1555] = 1555, + [1556] = 1539, + [1557] = 1539, + [1558] = 1558, + [1559] = 1559, + [1560] = 1539, + [1561] = 1561, + [1562] = 1562, + [1563] = 1539, + [1564] = 1555, + [1565] = 1540, + [1566] = 1566, + [1567] = 1567, + [1568] = 1568, + [1569] = 1569, + [1570] = 1570, + [1571] = 1569, + [1572] = 1569, + [1573] = 1573, + [1574] = 1569, + [1575] = 1575, + [1576] = 1095, + [1577] = 1577, + [1578] = 1578, + [1579] = 1579, + [1580] = 1569, + [1581] = 1098, + [1582] = 1579, + [1583] = 1569, + [1584] = 1092, + [1585] = 1585, + [1586] = 1569, + [1587] = 1569, + [1588] = 1569, + [1589] = 1569, + [1590] = 1569, + [1591] = 1569, + [1592] = 1569, + [1593] = 1593, + [1594] = 1594, + [1595] = 1595, + [1596] = 1596, + [1597] = 1594, + [1598] = 1598, + [1599] = 1599, + [1600] = 1594, + [1601] = 1596, + [1602] = 1602, + [1603] = 1603, + [1604] = 1604, + [1605] = 1605, + [1606] = 1606, + [1607] = 1607, + [1608] = 1594, + [1609] = 1594, + [1610] = 1610, + [1611] = 1611, + [1612] = 1598, + [1613] = 1613, + [1614] = 1598, + [1615] = 1615, + [1616] = 1616, + [1617] = 1607, + [1618] = 1598, + [1619] = 1619, + [1620] = 1613, + [1621] = 1594, + [1622] = 1613, + [1623] = 1598, + [1624] = 1594, + [1625] = 1625, + [1626] = 1625, + [1627] = 1625, + [1628] = 1613, + [1629] = 1602, + [1630] = 1613, + [1631] = 1613, + [1632] = 1632, + [1633] = 1596, + [1634] = 1613, + [1635] = 1635, + [1636] = 1636, + [1637] = 1625, + [1638] = 1594, + [1639] = 1625, + [1640] = 1615, + [1641] = 1602, + [1642] = 1596, + [1643] = 1643, + [1644] = 1602, + [1645] = 1605, + [1646] = 1596, + [1647] = 1602, + [1648] = 1648, + [1649] = 1649, + [1650] = 1650, + [1651] = 1651, + [1652] = 1652, + [1653] = 1625, + [1654] = 1654, + [1655] = 1607, + [1656] = 1607, + [1657] = 1625, + [1658] = 1658, + [1659] = 1659, + [1660] = 1602, + [1661] = 1594, + [1662] = 1598, + [1663] = 1663, + [1664] = 1664, + [1665] = 1665, + [1666] = 1594, + [1667] = 1602, + [1668] = 1668, + [1669] = 1669, + [1670] = 1670, + [1671] = 1596, + [1672] = 1607, + [1673] = 1611, + [1674] = 1613, + [1675] = 1675, + [1676] = 1676, + [1677] = 1602, + [1678] = 1678, + [1679] = 1607, + [1680] = 1598, + [1681] = 1681, + [1682] = 1596, + [1683] = 1683, + [1684] = 1596, + [1685] = 1685, + [1686] = 1598, + [1687] = 1613, + [1688] = 1607, + [1689] = 1596, + [1690] = 1625, + [1691] = 1594, + [1692] = 1692, + [1693] = 1693, + [1694] = 1694, + [1695] = 1602, + [1696] = 1596, + [1697] = 1697, + [1698] = 1678, + [1699] = 1699, + [1700] = 1700, + [1701] = 1701, + [1702] = 1613, + [1703] = 1703, + [1704] = 1625, + [1705] = 1602, + [1706] = 1706, + [1707] = 1707, + [1708] = 1708, + [1709] = 1594, + [1710] = 1607, + [1711] = 1596, + [1712] = 1632, + [1713] = 1713, + [1714] = 1714, + [1715] = 1699, + [1716] = 1613, + [1717] = 1717, + [1718] = 1625, + [1719] = 1607, + [1720] = 1607, + [1721] = 1602, + [1722] = 1598, + [1723] = 1598, + [1724] = 1598, + [1725] = 1598, + [1726] = 1607, + [1727] = 1663, + [1728] = 1728, + [1729] = 1625, + [1730] = 1607, + [1731] = 1731, + [1732] = 1594, + [1733] = 1613, + [1734] = 1602, + [1735] = 1625, + [1736] = 1602, + [1737] = 1596, + [1738] = 1643, + [1739] = 1619, + [1740] = 1643, + [1741] = 1643, + [1742] = 1643, + [1743] = 1643, + [1744] = 1643, + [1745] = 1643, + [1746] = 1643, + [1747] = 1643, + [1748] = 1643, + [1749] = 1643, + [1750] = 1669, + [1751] = 1669, + [1752] = 1669, + [1753] = 1669, + [1754] = 1669, + [1755] = 1669, + [1756] = 1669, + [1757] = 1669, + [1758] = 1669, + [1759] = 1669, + [1760] = 1669, + [1761] = 1761, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(352); + ADVANCE_MAP( + '"', 580, + '#', 512, + '\'', 573, + '(', 550, + ')', 552, + '*', 564, + '+', 555, + ',', 370, + '-', 549, + '.', 514, + '/', 548, + '1', 567, + ':', 358, + ';', 371, + '<', 560, + '=', 355, + '>', 561, + 'A', 147, + 'B', 71, + 'C', 35, + 'D', 107, + 'E', 137, + 'F', 36, + 'I', 94, + 'L', 207, + 'M', 182, + 'N', 179, + 'O', 95, + 'R', 73, + 'S', 121, + 'T', 19, + 'U', 123, + 'V', 39, + 'W', 57, + 'X', 185, + '[', 488, + ']', 489, + 'b', 347, + 'c', 290, + 'd', 297, + 'i', 312, + 'l', 333, + 'r', 284, + 's', 299, + 't', 298, + 'u', 300, + 'w', 273, + '{', 369, + '}', 372, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(0); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + END_STATE(); + case 1: + if (lookahead == '\n') SKIP(1); + if (lookahead == '\'') ADVANCE(573); + if (lookahead == '(') ADVANCE(576); + if (lookahead == '/') ADVANCE(577); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(575); + if (lookahead != 0) ADVANCE(574); + END_STATE(); + case 2: + if (lookahead == '\n') SKIP(2); + if (lookahead == '"') ADVANCE(580); + if (lookahead == '(') ADVANCE(583); + if (lookahead == '/') ADVANCE(584); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(582); + if (lookahead != 0) ADVANCE(581); + END_STATE(); + case 3: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 550, + '+', 555, + '-', 549, + '/', 32, + '1', 567, + 'N', 776, + 'T', 586, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(3); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 4: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + ')', 552, + '-', 549, + '/', 548, + '}', 372, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(4); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 5: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 851, + 'F', 760, + 'I', 655, + 'R', 634, + 'U', 750, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(5); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 6: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 705, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(6); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 7: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 737, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(7); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 8: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 712, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(8); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 9: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 738, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(9); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 10: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 734, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(10); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 11: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 739, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(11); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 12: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 740, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(12); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 13: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 736, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(13); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 14: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 742, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(14); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 15: + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 27, + '-', 549, + '/', 548, + ';', 371, + 'C', 587, + 'E', 758, + 'F', 760, + 'I', 655, + 'R', 634, + 'V', 589, + 'W', 667, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(15); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 16: + ADVANCE_MAP( + '"', 579, + '\'', 572, + '(', 27, + '.', 31, + '/', 32, + ':', 357, + 'A', 795, + 'B', 766, + 'C', 668, + 'D', 686, + 'I', 744, + 'L', 798, + 'R', 650, + 'S', 687, + 'T', 675, + 'U', 689, + 'W', 619, + 'b', 949, + 'c', 894, + 'd', 900, + 'i', 914, + 'l', 935, + 'r', 888, + 's', 902, + 't', 901, + 'u', 903, + 'w', 877, + '{', 369, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(16); + if (('E' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 17: + if (lookahead == '"') ADVANCE(579); + if (lookahead == '\'') ADVANCE(572); + if (lookahead == '(') ADVANCE(27); + if (lookahead == '/') ADVANCE(32); + if (lookahead == 'F') ADVANCE(595); + if (lookahead == 'T') ADVANCE(799); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(17); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 18: + if (lookahead == '#') ADVANCE(512); + if (lookahead == '(') ADVANCE(27); + if (lookahead == '/') ADVANCE(32); + if (lookahead == 'E') ADVANCE(713); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(18); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 19: + if (lookahead == '#') ADVANCE(349); + if (lookahead == 'H') ADVANCE(87); + if (lookahead == 'I') ADVANCE(145); + if (lookahead == 'O') ADVANCE(530); + if (lookahead == 'R') ADVANCE(250); + if (lookahead == 'i') ADVANCE(307); + if (lookahead == 'o') ADVANCE(274); + END_STATE(); + case 20: + ADVANCE_MAP( + '(', 550, + ')', 552, + '*', 564, + '+', 555, + ',', 370, + '-', 549, + '.', 513, + '/', 548, + ':', 34, + ';', 371, + '<', 560, + '=', 355, + '>', 561, + 'A', 146, + 'B', 72, + 'D', 178, + 'E', 169, + 'M', 182, + 'O', 95, + 'T', 103, + 'V', 39, + 'X', 185, + '[', 488, + ']', 489, + '{', 369, + '}', 372, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(20); + END_STATE(); + case 21: + ADVANCE_MAP( + '(', 27, + ')', 552, + '*', 564, + '+', 555, + ',', 370, + '-', 549, + '.', 513, + '/', 548, + ':', 358, + ';', 371, + '<', 560, + '=', 355, + '>', 561, + 'A', 146, + 'B', 256, + 'D', 178, + 'E', 169, + 'M', 182, + 'O', 95, + 'T', 104, + 'X', 185, + '[', 488, + ']', 489, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(21); + END_STATE(); + case 22: + if (lookahead == '(') ADVANCE(27); + if (lookahead == '/') ADVANCE(32); + if (lookahead == ':') ADVANCE(357); + if (lookahead == 'B') ADVANCE(70); + if (lookahead == 'T') ADVANCE(118); + if (lookahead == 'V') ADVANCE(39); + if (lookahead == '{') ADVANCE(369); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(22); + END_STATE(); + case 23: + if (lookahead == '(') ADVANCE(27); + if (lookahead == '/') ADVANCE(32); + if (lookahead == 'C') ADVANCE(778); + if (lookahead == 'E') ADVANCE(743); + if (lookahead == 'N') ADVANCE(781); + if (lookahead == 'R') ADVANCE(653); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(23); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 24: + if (lookahead == '(') ADVANCE(27); + if (lookahead == '/') ADVANCE(32); + if (lookahead == 'E') ADVANCE(743); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(24); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 25: + if (lookahead == ')') ADVANCE(952); + if (lookahead != 0) ADVANCE(28); + END_STATE(); + case 26: + if (lookahead == ')') ADVANCE(953); + if (lookahead == '*') ADVANCE(33); + if (lookahead != 0) ADVANCE(29); + END_STATE(); + case 27: + if (lookahead == '*') ADVANCE(28); + if (lookahead == '/') ADVANCE(30); + END_STATE(); + case 28: + if (lookahead == '*') ADVANCE(25); + if (lookahead != 0) ADVANCE(28); + END_STATE(); + case 29: + if (lookahead == '*') ADVANCE(33); + if (lookahead != 0) ADVANCE(29); + END_STATE(); + case 30: + if (lookahead == '*') ADVANCE(29); + END_STATE(); + case 31: + if (lookahead == '.') ADVANCE(510); + END_STATE(); + case 32: + if (lookahead == '/') ADVANCE(951); + END_STATE(); + case 33: + if (lookahead == '/') ADVANCE(26); + if (lookahead != 0 && + lookahead != ')') ADVANCE(29); + END_STATE(); + case 34: + if (lookahead == '=') ADVANCE(373); + END_STATE(); + case 35: + if (lookahead == 'A') ADVANCE(219); + if (lookahead == 'H') ADVANCE(42); + if (lookahead == 'O') ADVANCE(148); + if (lookahead == 'h') ADVANCE(267); + END_STATE(); + case 36: + if (lookahead == 'A') ADVANCE(143); + if (lookahead == 'O') ADVANCE(200); + if (lookahead == 'U') ADVANCE(149); + END_STATE(); + case 37: + if (lookahead == 'A') ADVANCE(257); + END_STATE(); + case 38: + if (lookahead == 'A') ADVANCE(134); + if (lookahead == 'G') ADVANCE(111); + if (lookahead == 'P') ADVANCE(89); + if (lookahead == 'T') ADVANCE(41); + END_STATE(); + case 39: + if (lookahead == 'A') ADVANCE(201); + if (lookahead == 'E') ADVANCE(210); + END_STATE(); + case 40: + if (lookahead == 'A') ADVANCE(135); + END_STATE(); + case 41: + if (lookahead == 'A') ADVANCE(115); + END_STATE(); + case 42: + if (lookahead == 'A') ADVANCE(203); + END_STATE(); + case 43: + if (lookahead == 'A') ADVANCE(231); + END_STATE(); + case 44: + if (lookahead == 'A') ADVANCE(173); + END_STATE(); + case 45: + if (lookahead == 'A') ADVANCE(204); + END_STATE(); + case 46: + if (lookahead == 'A') ADVANCE(235); + END_STATE(); + case 47: + if (lookahead == 'A') ADVANCE(206); + END_STATE(); + case 48: + if (lookahead == 'A') ADVANCE(172); + END_STATE(); + case 49: + if (lookahead == 'A') ADVANCE(117); + END_STATE(); + case 50: + if (lookahead == 'A') ADVANCE(174); + END_STATE(); + case 51: + if (lookahead == 'A') ADVANCE(222); + END_STATE(); + case 52: + if (lookahead == 'A') ADVANCE(119); + END_STATE(); + case 53: + if (lookahead == 'A') ADVANCE(120); + END_STATE(); + case 54: + if (lookahead == 'A') ADVANCE(249); + END_STATE(); + case 55: + if (lookahead == 'B') ADVANCE(138); + END_STATE(); + case 56: + if (lookahead == 'B') ADVANCE(140); + END_STATE(); + case 57: + if (lookahead == 'C') ADVANCE(105); + if (lookahead == 'H') ADVANCE(122); + if (lookahead == 'O') ADVANCE(211); + if (lookahead == 'S') ADVANCE(242); + if (lookahead == 'o') ADVANCE(326); + END_STATE(); + case 58: + if (lookahead == 'C') ADVANCE(131); + END_STATE(); + case 59: + if (lookahead == 'C') ADVANCE(132); + END_STATE(); + case 60: + if (lookahead == 'C') ADVANCE(51); + if (lookahead == 'F') ADVANCE(189); + if (lookahead == 'I') ADVANCE(97); + if (lookahead == 'O') ADVANCE(209); + if (lookahead == 'R') ADVANCE(81); + if (lookahead == 'V') ADVANCE(47); + if (lookahead == 'W') ADVANCE(106); + END_STATE(); + case 61: + if (lookahead == 'C') ADVANCE(246); + END_STATE(); + case 62: + if (lookahead == 'C') ADVANCE(187); + if (lookahead == 'I') ADVANCE(154); + if (lookahead == 'N') ADVANCE(188); + if (lookahead == 'O') ADVANCE(251); + if (lookahead == 'R') ADVANCE(92); + if (lookahead == 'T') ADVANCE(82); + END_STATE(); + case 63: + if (lookahead == 'C') ADVANCE(248); + END_STATE(); + case 64: + if (lookahead == 'D') ADVANCE(558); + END_STATE(); + case 65: + if (lookahead == 'D') ADVANCE(259); + END_STATE(); + case 66: + if (lookahead == 'D') ADVANCE(565); + END_STATE(); + case 67: + if (lookahead == 'D') ADVANCE(436); + END_STATE(); + case 68: + if (lookahead == 'D') ADVANCE(442); + END_STATE(); + case 69: + if (lookahead == 'D') ADVANCE(262); + END_STATE(); + case 70: + if (lookahead == 'E') ADVANCE(100); + END_STATE(); + case 71: + if (lookahead == 'E') ADVANCE(100); + if (lookahead == 'O') ADVANCE(180); + if (lookahead == 'Y') ADVANCE(531); + if (lookahead == 'o') ADVANCE(319); + if (lookahead == 'y') ADVANCE(344); + END_STATE(); + case 72: + if (lookahead == 'E') ADVANCE(100); + if (lookahead == 'Y') ADVANCE(531); + END_STATE(); + case 73: + if (lookahead == 'E') ADVANCE(38); + if (lookahead == 'e') ADVANCE(265); + END_STATE(); + case 74: + if (lookahead == 'E') ADVANCE(524); + END_STATE(); + case 75: + if (lookahead == 'E') ADVANCE(522); + if (lookahead == 'I') ADVANCE(96); + END_STATE(); + case 76: + if (lookahead == 'E') ADVANCE(465); + END_STATE(); + case 77: + if (lookahead == 'E') ADVANCE(374); + END_STATE(); + case 78: + if (lookahead == 'E') ADVANCE(376); + END_STATE(); + case 79: + if (lookahead == 'E') ADVANCE(354); + END_STATE(); + case 80: + if (lookahead == 'E') ADVANCE(535); + END_STATE(); + case 81: + if (lookahead == 'E') ADVANCE(102); + END_STATE(); + case 82: + if (lookahead == 'E') ADVANCE(144); + END_STATE(); + case 83: + if (lookahead == 'E') ADVANCE(956); + END_STATE(); + case 84: + if (lookahead == 'E') ADVANCE(526); + END_STATE(); + case 85: + if (lookahead == 'E') ADVANCE(537); + END_STATE(); + case 86: + if (lookahead == 'E') ADVANCE(40); + if (lookahead == 'e') ADVANCE(268); + END_STATE(); + case 87: + if (lookahead == 'E') ADVANCE(150); + END_STATE(); + case 88: + if (lookahead == 'E') ADVANCE(199); + END_STATE(); + case 89: + if (lookahead == 'E') ADVANCE(43); + END_STATE(); + case 90: + if (lookahead == 'E') ADVANCE(243); + END_STATE(); + case 91: + if (lookahead == 'E') ADVANCE(46); + END_STATE(); + case 92: + if (lookahead == 'E') ADVANCE(245); + END_STATE(); + case 93: + if (lookahead == 'E') ADVANCE(247); + END_STATE(); + case 94: + if (lookahead == 'F') ADVANCE(515); + if (lookahead == 'N') ADVANCE(225); + if (lookahead == 'n') ADVANCE(334); + END_STATE(); + case 95: + if (lookahead == 'F') ADVANCE(511); + if (lookahead == 'R') ADVANCE(556); + END_STATE(); + case 96: + if (lookahead == 'F') ADVANCE(520); + END_STATE(); + case 97: + if (lookahead == 'F') ADVANCE(518); + END_STATE(); + case 98: + if (lookahead == 'G') ADVANCE(484); + END_STATE(); + case 99: + if (lookahead == 'G') ADVANCE(492); + END_STATE(); + case 100: + if (lookahead == 'G') ADVANCE(109); + END_STATE(); + case 101: + if (lookahead == 'G') ADVANCE(48); + END_STATE(); + case 102: + if (lookahead == 'G') ADVANCE(128); + if (lookahead == 'P') ADVANCE(91); + END_STATE(); + case 103: + if (lookahead == 'H') ADVANCE(87); + if (lookahead == 'I') ADVANCE(239); + if (lookahead == 'O') ADVANCE(530); + END_STATE(); + case 104: + if (lookahead == 'H') ADVANCE(87); + if (lookahead == 'O') ADVANCE(530); + END_STATE(); + case 105: + if (lookahead == 'H') ADVANCE(45); + if (lookahead == 'h') ADVANCE(271); + END_STATE(); + case 106: + if (lookahead == 'H') ADVANCE(124); + END_STATE(); + case 107: + if (lookahead == 'I') ADVANCE(164); + if (lookahead == 'O') ADVANCE(532); + if (lookahead == 'T') ADVANCE(476); + if (lookahead == 'W') ADVANCE(186); + if (lookahead == 't') ADVANCE(478); + END_STATE(); + case 108: + if (lookahead == 'I') ADVANCE(258); + END_STATE(); + case 109: + if (lookahead == 'I') ADVANCE(151); + END_STATE(); + case 110: + if (lookahead == 'I') ADVANCE(227); + END_STATE(); + case 111: + if (lookahead == 'I') ADVANCE(184); + END_STATE(); + case 112: + if (lookahead == 'I') ADVANCE(162); + END_STATE(); + case 113: + if (lookahead == 'I') ADVANCE(175); + END_STATE(); + case 114: + if (lookahead == 'I') ADVANCE(136); + END_STATE(); + case 115: + if (lookahead == 'I') ADVANCE(153); + END_STATE(); + case 116: + if (lookahead == 'I') ADVANCE(166); + END_STATE(); + case 117: + if (lookahead == 'I') ADVANCE(158); + END_STATE(); + case 118: + if (lookahead == 'I') ADVANCE(239); + END_STATE(); + case 119: + if (lookahead == 'I') ADVANCE(159); + END_STATE(); + case 120: + if (lookahead == 'I') ADVANCE(161); + END_STATE(); + case 121: + if (lookahead == 'I') ADVANCE(168); + if (lookahead == 'T') ADVANCE(213); + if (lookahead == 't') ADVANCE(325); + END_STATE(); + case 122: + if (lookahead == 'I') ADVANCE(141); + END_STATE(); + case 123: + if (lookahead == 'I') ADVANCE(170); + if (lookahead == 'N') ADVANCE(241); + if (lookahead == 'S') ADVANCE(125); + END_STATE(); + case 124: + if (lookahead == 'I') ADVANCE(142); + END_STATE(); + case 125: + if (lookahead == 'I') ADVANCE(171); + END_STATE(); + case 126: + if (lookahead == 'I') ADVANCE(190); + END_STATE(); + case 127: + if (lookahead == 'I') ADVANCE(191); + END_STATE(); + case 128: + if (lookahead == 'I') ADVANCE(192); + END_STATE(); + case 129: + if (lookahead == 'I') ADVANCE(193); + END_STATE(); + case 130: + if (lookahead == 'I') ADVANCE(194); + END_STATE(); + case 131: + if (lookahead == 'K') ADVANCE(362); + END_STATE(); + case 132: + if (lookahead == 'K') ADVANCE(360); + END_STATE(); + case 133: + if (lookahead == 'L') ADVANCE(402); + END_STATE(); + case 134: + if (lookahead == 'L') ADVANCE(453); + END_STATE(); + case 135: + if (lookahead == 'L') ADVANCE(459); + END_STATE(); + case 136: + if (lookahead == 'L') ADVANCE(541); + END_STATE(); + case 137: + if (lookahead == 'L') ADVANCE(218); + if (lookahead == 'N') ADVANCE(65); + if (lookahead == 'X') ADVANCE(110); + END_STATE(); + case 138: + if (lookahead == 'L') ADVANCE(181); + END_STATE(); + case 139: + if (lookahead == 'L') ADVANCE(79); + END_STATE(); + case 140: + if (lookahead == 'L') ADVANCE(183); + END_STATE(); + case 141: + if (lookahead == 'L') ADVANCE(80); + END_STATE(); + case 142: + if (lookahead == 'L') ADVANCE(85); + END_STATE(); + case 143: + if (lookahead == 'L') ADVANCE(220); + END_STATE(); + case 144: + if (lookahead == 'M') ADVANCE(196); + END_STATE(); + case 145: + if (lookahead == 'M') ADVANCE(76); + if (lookahead == 'T') ADVANCE(139); + END_STATE(); + case 146: + if (lookahead == 'N') ADVANCE(64); + END_STATE(); + case 147: + if (lookahead == 'N') ADVANCE(64); + if (lookahead == 'R') ADVANCE(208); + END_STATE(); + case 148: + if (lookahead == 'N') ADVANCE(221); + END_STATE(); + case 149: + if (lookahead == 'N') ADVANCE(61); + END_STATE(); + case 150: + if (lookahead == 'N') ADVANCE(517); + END_STATE(); + case 151: + if (lookahead == 'N') ADVANCE(359); + END_STATE(); + case 152: + if (lookahead == 'N') ADVANCE(544); + END_STATE(); + case 153: + if (lookahead == 'N') ADVANCE(390); + END_STATE(); + case 154: + if (lookahead == 'N') ADVANCE(197); + END_STATE(); + case 155: + if (lookahead == 'N') ADVANCE(356); + END_STATE(); + case 156: + if (lookahead == 'N') ADVANCE(365); + END_STATE(); + case 157: + if (lookahead == 'N') ADVANCE(546); + END_STATE(); + case 158: + if (lookahead == 'N') ADVANCE(392); + END_STATE(); + case 159: + if (lookahead == 'N') ADVANCE(396); + END_STATE(); + case 160: + if (lookahead == 'N') ADVANCE(367); + END_STATE(); + case 161: + if (lookahead == 'N') ADVANCE(398); + END_STATE(); + case 162: + if (lookahead == 'N') ADVANCE(98); + END_STATE(); + case 163: + if (lookahead == 'N') ADVANCE(261); + if (lookahead == 'T') ADVANCE(553); + END_STATE(); + case 164: + if (lookahead == 'N') ADVANCE(226); + if (lookahead == 'n') ADVANCE(336); + END_STATE(); + case 165: + if (lookahead == 'N') ADVANCE(263); + END_STATE(); + case 166: + if (lookahead == 'N') ADVANCE(99); + END_STATE(); + case 167: + if (lookahead == 'N') ADVANCE(224); + END_STATE(); + case 168: + if (lookahead == 'N') ADVANCE(228); + if (lookahead == 'n') ADVANCE(337); + END_STATE(); + case 169: + if (lookahead == 'N') ADVANCE(69); + END_STATE(); + case 170: + if (lookahead == 'N') ADVANCE(229); + if (lookahead == 'n') ADVANCE(338); + END_STATE(); + case 171: + if (lookahead == 'N') ADVANCE(230); + if (lookahead == 'n') ADVANCE(342); + END_STATE(); + case 172: + if (lookahead == 'N') ADVANCE(108); + END_STATE(); + case 173: + if (lookahead == 'N') ADVANCE(233); + END_STATE(); + case 174: + if (lookahead == 'N') ADVANCE(238); + END_STATE(); + case 175: + if (lookahead == 'N') ADVANCE(252); + END_STATE(); + case 176: + if (lookahead == 'N') ADVANCE(63); + END_STATE(); + case 177: + if (lookahead == 'N') ADVANCE(264); + END_STATE(); + case 178: + if (lookahead == 'O') ADVANCE(532); + END_STATE(); + case 179: + if (lookahead == 'O') ADVANCE(163); + END_STATE(); + case 180: + if (lookahead == 'O') ADVANCE(133); + END_STATE(); + case 181: + if (lookahead == 'O') ADVANCE(58); + END_STATE(); + case 182: + if (lookahead == 'O') ADVANCE(66); + END_STATE(); + case 183: + if (lookahead == 'O') ADVANCE(59); + END_STATE(); + case 184: + if (lookahead == 'O') ADVANCE(152); + END_STATE(); + case 185: + if (lookahead == 'O') ADVANCE(202); + END_STATE(); + case 186: + if (lookahead == 'O') ADVANCE(212); + if (lookahead == 'o') ADVANCE(330); + END_STATE(); + case 187: + if (lookahead == 'O') ADVANCE(167); + END_STATE(); + case 188: + if (lookahead == 'O') ADVANCE(177); + END_STATE(); + case 189: + if (lookahead == 'O') ADVANCE(205); + if (lookahead == 'U') ADVANCE(176); + END_STATE(); + case 190: + if (lookahead == 'O') ADVANCE(155); + END_STATE(); + case 191: + if (lookahead == 'O') ADVANCE(156); + END_STATE(); + case 192: + if (lookahead == 'O') ADVANCE(157); + END_STATE(); + case 193: + if (lookahead == 'O') ADVANCE(160); + END_STATE(); + case 194: + if (lookahead == 'O') ADVANCE(165); + END_STATE(); + case 195: + if (lookahead == 'O') ADVANCE(254); + END_STATE(); + case 196: + if (lookahead == 'P') ADVANCE(386); + END_STATE(); + case 197: + if (lookahead == 'P') ADVANCE(253); + if (lookahead == '_') ADVANCE(195); + END_STATE(); + case 198: + if (lookahead == 'P') ADVANCE(255); + END_STATE(); + case 199: + if (lookahead == 'P') ADVANCE(91); + END_STATE(); + case 200: + if (lookahead == 'R') ADVANCE(528); + END_STATE(); + case 201: + if (lookahead == 'R') ADVANCE(384); + END_STATE(); + case 202: + if (lookahead == 'R') ADVANCE(557); + END_STATE(); + case 203: + if (lookahead == 'R') ADVANCE(498); + END_STATE(); + case 204: + if (lookahead == 'R') ADVANCE(504); + END_STATE(); + case 205: + if (lookahead == 'R') ADVANCE(533); + END_STATE(); + case 206: + if (lookahead == 'R') ADVANCE(400); + END_STATE(); + case 207: + if (lookahead == 'R') ADVANCE(86); + END_STATE(); + case 208: + if (lookahead == 'R') ADVANCE(37); + END_STATE(); + case 209: + if (lookahead == 'R') ADVANCE(101); + END_STATE(); + case 210: + if (lookahead == 'R') ADVANCE(223); + END_STATE(); + case 211: + if (lookahead == 'R') ADVANCE(67); + END_STATE(); + case 212: + if (lookahead == 'R') ADVANCE(68); + END_STATE(); + case 213: + if (lookahead == 'R') ADVANCE(112); + END_STATE(); + case 214: + if (lookahead == 'R') ADVANCE(116); + END_STATE(); + case 215: + if (lookahead == 'R') ADVANCE(90); + END_STATE(); + case 216: + if (lookahead == 'R') ADVANCE(88); + END_STATE(); + case 217: + if (lookahead == 'R') ADVANCE(93); + END_STATE(); + case 218: + if (lookahead == 'S') ADVANCE(75); + END_STATE(); + case 219: + if (lookahead == 'S') ADVANCE(74); + END_STATE(); + case 220: + if (lookahead == 'S') ADVANCE(78); + END_STATE(); + case 221: + if (lookahead == 'S') ADVANCE(240); + if (lookahead == 'T') ADVANCE(113); + END_STATE(); + case 222: + if (lookahead == 'S') ADVANCE(84); + END_STATE(); + case 223: + if (lookahead == 'S') ADVANCE(126); + END_STATE(); + case 224: + if (lookahead == 'S') ADVANCE(244); + END_STATE(); + case 225: + if (lookahead == 'T') ADVANCE(406); + END_STATE(); + case 226: + if (lookahead == 'T') ADVANCE(412); + END_STATE(); + case 227: + if (lookahead == 'T') ADVANCE(954); + END_STATE(); + case 228: + if (lookahead == 'T') ADVANCE(418); + END_STATE(); + case 229: + if (lookahead == 'T') ADVANCE(430); + END_STATE(); + case 230: + if (lookahead == 'T') ADVANCE(424); + END_STATE(); + case 231: + if (lookahead == 'T') ADVANCE(539); + END_STATE(); + case 232: + if (lookahead == 'T') ADVANCE(198); + END_STATE(); + case 233: + if (lookahead == 'T') ADVANCE(388); + END_STATE(); + case 234: + if (lookahead == 'T') ADVANCE(378); + END_STATE(); + case 235: + if (lookahead == 'T') ADVANCE(543); + END_STATE(); + case 236: + if (lookahead == 'T') ADVANCE(382); + END_STATE(); + case 237: + if (lookahead == 'T') ADVANCE(380); + END_STATE(); + case 238: + if (lookahead == 'T') ADVANCE(394); + END_STATE(); + case 239: + if (lookahead == 'T') ADVANCE(139); + END_STATE(); + case 240: + if (lookahead == 'T') ADVANCE(44); + END_STATE(); + case 241: + if (lookahead == 'T') ADVANCE(114); + END_STATE(); + case 242: + if (lookahead == 'T') ADVANCE(214); + if (lookahead == 't') ADVANCE(329); + END_STATE(); + case 243: + if (lookahead == 'T') ADVANCE(49); + END_STATE(); + case 244: + if (lookahead == 'T') ADVANCE(50); + END_STATE(); + case 245: + if (lookahead == 'T') ADVANCE(52); + END_STATE(); + case 246: + if (lookahead == 'T') ADVANCE(127); + END_STATE(); + case 247: + if (lookahead == 'T') ADVANCE(53); + END_STATE(); + case 248: + if (lookahead == 'T') ADVANCE(129); + END_STATE(); + case 249: + if (lookahead == 'T') ADVANCE(130); + END_STATE(); + case 250: + if (lookahead == 'U') ADVANCE(77); + END_STATE(); + case 251: + if (lookahead == 'U') ADVANCE(232); + END_STATE(); + case 252: + if (lookahead == 'U') ADVANCE(83); + END_STATE(); + case 253: + if (lookahead == 'U') ADVANCE(234); + END_STATE(); + case 254: + if (lookahead == 'U') ADVANCE(236); + END_STATE(); + case 255: + if (lookahead == 'U') ADVANCE(237); + END_STATE(); + case 256: + if (lookahead == 'Y') ADVANCE(531); + END_STATE(); + case 257: + if (lookahead == 'Y') ADVANCE(508); + END_STATE(); + case 258: + if (lookahead == 'Z') ADVANCE(54); + END_STATE(); + case 259: + if (lookahead == '_') ADVANCE(60); + END_STATE(); + case 260: + if (lookahead == '_') ADVANCE(349); + if (lookahead == 'm') ADVANCE(294); + if (lookahead == 'h' || + lookahead == 's') ADVANCE(571); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(260); + END_STATE(); + case 261: + if (lookahead == '_') ADVANCE(215); + END_STATE(); + case 262: + if (lookahead == '_') ADVANCE(216); + END_STATE(); + case 263: + if (lookahead == '_') ADVANCE(56); + END_STATE(); + case 264: + if (lookahead == '_') ADVANCE(217); + END_STATE(); + case 265: + if (lookahead == 'a') ADVANCE(303); + END_STATE(); + case 266: + if (lookahead == 'a') ADVANCE(304); + END_STATE(); + case 267: + if (lookahead == 'a') ADVANCE(321); + END_STATE(); + case 268: + if (lookahead == 'a') ADVANCE(305); + END_STATE(); + case 269: + if (lookahead == 'a') ADVANCE(322); + END_STATE(); + case 270: + if (lookahead == 'a') ADVANCE(306); + END_STATE(); + case 271: + if (lookahead == 'a') ADVANCE(323); + END_STATE(); + case 272: + if (lookahead == 'a') ADVANCE(324); + END_STATE(); + case 273: + if (lookahead == 'c') ADVANCE(291); + if (lookahead == 'o') ADVANCE(328); + if (lookahead == 's') ADVANCE(346); + END_STATE(); + case 274: + if (lookahead == 'd') ADVANCE(472); + END_STATE(); + case 275: + if (lookahead == 'd') ADVANCE(474); + END_STATE(); + case 276: + if (lookahead == 'd') ADVANCE(438); + END_STATE(); + case 277: + if (lookahead == 'd') ADVANCE(440); + END_STATE(); + case 278: + if (lookahead == 'd') ADVANCE(444); + END_STATE(); + case 279: + if (lookahead == 'd') ADVANCE(446); + END_STATE(); + case 280: + if (lookahead == 'e') ADVANCE(449); + END_STATE(); + case 281: + if (lookahead == 'e') ADVANCE(467); + END_STATE(); + case 282: + if (lookahead == 'e') ADVANCE(451); + END_STATE(); + case 283: + if (lookahead == 'e') ADVANCE(469); + END_STATE(); + case 284: + if (lookahead == 'e') ADVANCE(266); + END_STATE(); + case 285: + if (lookahead == 'e') ADVANCE(270); + END_STATE(); + case 286: + if (lookahead == 'g') ADVANCE(482); + END_STATE(); + case 287: + if (lookahead == 'g') ADVANCE(486); + END_STATE(); + case 288: + if (lookahead == 'g') ADVANCE(490); + END_STATE(); + case 289: + if (lookahead == 'g') ADVANCE(494); + END_STATE(); + case 290: + if (lookahead == 'h') ADVANCE(269); + END_STATE(); + case 291: + if (lookahead == 'h') ADVANCE(272); + END_STATE(); + case 292: + if (lookahead == 'i') ADVANCE(310); + END_STATE(); + case 293: + if (lookahead == 'i') ADVANCE(311); + END_STATE(); + case 294: + if (lookahead == 'i') ADVANCE(309); + if (lookahead == 's') ADVANCE(571); + END_STATE(); + case 295: + if (lookahead == 'i') ADVANCE(313); + END_STATE(); + case 296: + if (lookahead == 'i') ADVANCE(314); + END_STATE(); + case 297: + if (lookahead == 'i') ADVANCE(315); + if (lookahead == 't') ADVANCE(480); + if (lookahead == 'w') ADVANCE(320); + END_STATE(); + case 298: + if (lookahead == 'i') ADVANCE(308); + if (lookahead == 'o') ADVANCE(275); + END_STATE(); + case 299: + if (lookahead == 'i') ADVANCE(316); + if (lookahead == 't') ADVANCE(327); + END_STATE(); + case 300: + if (lookahead == 'i') ADVANCE(317); + if (lookahead == 's') ADVANCE(301); + END_STATE(); + case 301: + if (lookahead == 'i') ADVANCE(318); + END_STATE(); + case 302: + if (lookahead == 'l') ADVANCE(404); + END_STATE(); + case 303: + if (lookahead == 'l') ADVANCE(455); + END_STATE(); + case 304: + if (lookahead == 'l') ADVANCE(457); + END_STATE(); + case 305: + if (lookahead == 'l') ADVANCE(461); + END_STATE(); + case 306: + if (lookahead == 'l') ADVANCE(463); + END_STATE(); + case 307: + if (lookahead == 'm') ADVANCE(281); + END_STATE(); + case 308: + if (lookahead == 'm') ADVANCE(283); + END_STATE(); + case 309: + if (lookahead == 'n') ADVANCE(571); + END_STATE(); + case 310: + if (lookahead == 'n') ADVANCE(286); + END_STATE(); + case 311: + if (lookahead == 'n') ADVANCE(287); + END_STATE(); + case 312: + if (lookahead == 'n') ADVANCE(335); + END_STATE(); + case 313: + if (lookahead == 'n') ADVANCE(288); + END_STATE(); + case 314: + if (lookahead == 'n') ADVANCE(289); + END_STATE(); + case 315: + if (lookahead == 'n') ADVANCE(339); + END_STATE(); + case 316: + if (lookahead == 'n') ADVANCE(340); + END_STATE(); + case 317: + if (lookahead == 'n') ADVANCE(341); + END_STATE(); + case 318: + if (lookahead == 'n') ADVANCE(343); + END_STATE(); + case 319: + if (lookahead == 'o') ADVANCE(302); + END_STATE(); + case 320: + if (lookahead == 'o') ADVANCE(331); + END_STATE(); + case 321: + if (lookahead == 'r') ADVANCE(496); + END_STATE(); + case 322: + if (lookahead == 'r') ADVANCE(500); + END_STATE(); + case 323: + if (lookahead == 'r') ADVANCE(502); + END_STATE(); + case 324: + if (lookahead == 'r') ADVANCE(506); + END_STATE(); + case 325: + if (lookahead == 'r') ADVANCE(292); + END_STATE(); + case 326: + if (lookahead == 'r') ADVANCE(276); + END_STATE(); + case 327: + if (lookahead == 'r') ADVANCE(293); + END_STATE(); + case 328: + if (lookahead == 'r') ADVANCE(277); + END_STATE(); + case 329: + if (lookahead == 'r') ADVANCE(295); + END_STATE(); + case 330: + if (lookahead == 'r') ADVANCE(278); + END_STATE(); + case 331: + if (lookahead == 'r') ADVANCE(279); + END_STATE(); + case 332: + if (lookahead == 'r') ADVANCE(296); + END_STATE(); + case 333: + if (lookahead == 'r') ADVANCE(285); + END_STATE(); + case 334: + if (lookahead == 't') ADVANCE(408); + END_STATE(); + case 335: + if (lookahead == 't') ADVANCE(410); + END_STATE(); + case 336: + if (lookahead == 't') ADVANCE(414); + END_STATE(); + case 337: + if (lookahead == 't') ADVANCE(420); + END_STATE(); + case 338: + if (lookahead == 't') ADVANCE(432); + END_STATE(); + case 339: + if (lookahead == 't') ADVANCE(416); + END_STATE(); + case 340: + if (lookahead == 't') ADVANCE(422); + END_STATE(); + case 341: + if (lookahead == 't') ADVANCE(434); + END_STATE(); + case 342: + if (lookahead == 't') ADVANCE(426); + END_STATE(); + case 343: + if (lookahead == 't') ADVANCE(428); + END_STATE(); + case 344: + if (lookahead == 't') ADVANCE(280); + END_STATE(); + case 345: + if (lookahead == 't') ADVANCE(282); + END_STATE(); + case 346: + if (lookahead == 't') ADVANCE(332); + END_STATE(); + case 347: + if (lookahead == 'y') ADVANCE(345); + END_STATE(); + case 348: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(569); + END_STATE(); + case 349: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(260); + END_STATE(); + case 350: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(570); + END_STATE(); + case 351: + if (eof) ADVANCE(352); + ADVANCE_MAP( + '"', 579, + '#', 512, + '\'', 572, + '(', 550, + '-', 549, + '.', 513, + '/', 548, + ':', 34, + ';', 371, + 'C', 587, + 'E', 851, + 'F', 759, + 'I', 655, + 'O', 786, + 'R', 634, + 'V', 589, + 'W', 667, + '[', 488, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(351); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 352: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 353: + ACCEPT_TOKEN(anon_sym_ORGANIZATION_BLOCK); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 354: + ACCEPT_TOKEN(anon_sym_TITLE); + END_STATE(); + case 355: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '>') ADVANCE(551); + END_STATE(); + case 356: + ACCEPT_TOKEN(anon_sym_VERSION); + END_STATE(); + case 357: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 358: + ACCEPT_TOKEN(anon_sym_COLON); + if (lookahead == '=') ADVANCE(373); + END_STATE(); + case 359: + ACCEPT_TOKEN(anon_sym_BEGIN); + END_STATE(); + case 360: + ACCEPT_TOKEN(anon_sym_END_ORGANIZATION_BLOCK); + END_STATE(); + case 361: + ACCEPT_TOKEN(anon_sym_END_ORGANIZATION_BLOCK); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 362: + ACCEPT_TOKEN(anon_sym_FUNCTION_BLOCK); + END_STATE(); + case 363: + ACCEPT_TOKEN(anon_sym_FUNCTION_BLOCK); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 364: + ACCEPT_TOKEN(anon_sym_END_FUNCTION_BLOCK); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 365: + ACCEPT_TOKEN(anon_sym_FUNCTION); + if (lookahead == '_') ADVANCE(55); + END_STATE(); + case 366: + ACCEPT_TOKEN(anon_sym_FUNCTION); + if (lookahead == '_') ADVANCE(608); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 367: + ACCEPT_TOKEN(anon_sym_END_FUNCTION); + END_STATE(); + case 368: + ACCEPT_TOKEN(anon_sym_END_FUNCTION); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 369: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 370: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 371: + ACCEPT_TOKEN(anon_sym_SEMI); + END_STATE(); + case 372: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 373: + ACCEPT_TOKEN(anon_sym_COLON_EQ); + END_STATE(); + case 374: + ACCEPT_TOKEN(anon_sym_TRUE); + END_STATE(); + case 375: + ACCEPT_TOKEN(anon_sym_TRUE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 376: + ACCEPT_TOKEN(anon_sym_FALSE); + END_STATE(); + case 377: + ACCEPT_TOKEN(anon_sym_FALSE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 378: + ACCEPT_TOKEN(anon_sym_VAR_INPUT); + END_STATE(); + case 379: + ACCEPT_TOKEN(anon_sym_VAR_INPUT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 380: + ACCEPT_TOKEN(anon_sym_VAR_OUTPUT); + END_STATE(); + case 381: + ACCEPT_TOKEN(anon_sym_VAR_OUTPUT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 382: + ACCEPT_TOKEN(anon_sym_VAR_IN_OUT); + END_STATE(); + case 383: + ACCEPT_TOKEN(anon_sym_VAR_IN_OUT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 384: + ACCEPT_TOKEN(anon_sym_VAR); + if (lookahead == '_') ADVANCE(62); + END_STATE(); + case 385: + ACCEPT_TOKEN(anon_sym_VAR); + if (lookahead == '_') ADVANCE(618); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 386: + ACCEPT_TOKEN(anon_sym_VAR_TEMP); + END_STATE(); + case 387: + ACCEPT_TOKEN(anon_sym_VAR_TEMP); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 388: + ACCEPT_TOKEN(anon_sym_CONSTANT); + END_STATE(); + case 389: + ACCEPT_TOKEN(anon_sym_CONSTANT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 390: + ACCEPT_TOKEN(anon_sym_RETAIN); + END_STATE(); + case 391: + ACCEPT_TOKEN(anon_sym_RETAIN); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 392: + ACCEPT_TOKEN(anon_sym_NON_RETAIN); + END_STATE(); + case 393: + ACCEPT_TOKEN(anon_sym_NON_RETAIN); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 394: + ACCEPT_TOKEN(anon_sym_VAR_CONSTANT); + END_STATE(); + case 395: + ACCEPT_TOKEN(anon_sym_VAR_CONSTANT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 396: + ACCEPT_TOKEN(anon_sym_VAR_RETAIN); + END_STATE(); + case 397: + ACCEPT_TOKEN(anon_sym_VAR_RETAIN); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 398: + ACCEPT_TOKEN(anon_sym_VAR_NON_RETAIN); + END_STATE(); + case 399: + ACCEPT_TOKEN(anon_sym_VAR_NON_RETAIN); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 400: + ACCEPT_TOKEN(anon_sym_END_VAR); + END_STATE(); + case 401: + ACCEPT_TOKEN(anon_sym_END_VAR); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 402: + ACCEPT_TOKEN(anon_sym_BOOL); + END_STATE(); + case 403: + ACCEPT_TOKEN(anon_sym_BOOL); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 404: + ACCEPT_TOKEN(anon_sym_Bool); + END_STATE(); + case 405: + ACCEPT_TOKEN(anon_sym_Bool); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 406: + ACCEPT_TOKEN(anon_sym_INT); + END_STATE(); + case 407: + ACCEPT_TOKEN(anon_sym_INT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 408: + ACCEPT_TOKEN(anon_sym_Int); + END_STATE(); + case 409: + ACCEPT_TOKEN(anon_sym_Int); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 410: + ACCEPT_TOKEN(anon_sym_int); + END_STATE(); + case 411: + ACCEPT_TOKEN(anon_sym_int); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 412: + ACCEPT_TOKEN(anon_sym_DINT); + END_STATE(); + case 413: + ACCEPT_TOKEN(anon_sym_DINT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 414: + ACCEPT_TOKEN(anon_sym_DInt); + END_STATE(); + case 415: + ACCEPT_TOKEN(anon_sym_DInt); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 416: + ACCEPT_TOKEN(anon_sym_dint); + END_STATE(); + case 417: + ACCEPT_TOKEN(anon_sym_dint); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 418: + ACCEPT_TOKEN(anon_sym_SINT); + END_STATE(); + case 419: + ACCEPT_TOKEN(anon_sym_SINT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 420: + ACCEPT_TOKEN(anon_sym_SInt); + END_STATE(); + case 421: + ACCEPT_TOKEN(anon_sym_SInt); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 422: + ACCEPT_TOKEN(anon_sym_sint); + END_STATE(); + case 423: + ACCEPT_TOKEN(anon_sym_sint); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 424: + ACCEPT_TOKEN(anon_sym_USINT); + END_STATE(); + case 425: + ACCEPT_TOKEN(anon_sym_USINT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 426: + ACCEPT_TOKEN(anon_sym_USInt); + END_STATE(); + case 427: + ACCEPT_TOKEN(anon_sym_USInt); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 428: + ACCEPT_TOKEN(anon_sym_usint); + END_STATE(); + case 429: + ACCEPT_TOKEN(anon_sym_usint); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 430: + ACCEPT_TOKEN(anon_sym_UINT); + END_STATE(); + case 431: + ACCEPT_TOKEN(anon_sym_UINT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 432: + ACCEPT_TOKEN(anon_sym_UInt); + END_STATE(); + case 433: + ACCEPT_TOKEN(anon_sym_UInt); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 434: + ACCEPT_TOKEN(anon_sym_uint); + END_STATE(); + case 435: + ACCEPT_TOKEN(anon_sym_uint); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 436: + ACCEPT_TOKEN(anon_sym_WORD); + END_STATE(); + case 437: + ACCEPT_TOKEN(anon_sym_WORD); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 438: + ACCEPT_TOKEN(anon_sym_Word); + END_STATE(); + case 439: + ACCEPT_TOKEN(anon_sym_Word); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 440: + ACCEPT_TOKEN(anon_sym_word); + END_STATE(); + case 441: + ACCEPT_TOKEN(anon_sym_word); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 442: + ACCEPT_TOKEN(anon_sym_DWORD); + END_STATE(); + case 443: + ACCEPT_TOKEN(anon_sym_DWORD); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 444: + ACCEPT_TOKEN(anon_sym_DWord); + END_STATE(); + case 445: + ACCEPT_TOKEN(anon_sym_DWord); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 446: + ACCEPT_TOKEN(anon_sym_dword); + END_STATE(); + case 447: + ACCEPT_TOKEN(anon_sym_dword); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 448: + ACCEPT_TOKEN(anon_sym_BYTE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 449: + ACCEPT_TOKEN(anon_sym_Byte); + END_STATE(); + case 450: + ACCEPT_TOKEN(anon_sym_Byte); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 451: + ACCEPT_TOKEN(anon_sym_byte); + END_STATE(); + case 452: + ACCEPT_TOKEN(anon_sym_byte); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 453: + ACCEPT_TOKEN(anon_sym_REAL); + END_STATE(); + case 454: + ACCEPT_TOKEN(anon_sym_REAL); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 455: + ACCEPT_TOKEN(anon_sym_Real); + END_STATE(); + case 456: + ACCEPT_TOKEN(anon_sym_Real); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 457: + ACCEPT_TOKEN(anon_sym_real); + END_STATE(); + case 458: + ACCEPT_TOKEN(anon_sym_real); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 459: + ACCEPT_TOKEN(anon_sym_LREAL); + END_STATE(); + case 460: + ACCEPT_TOKEN(anon_sym_LREAL); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 461: + ACCEPT_TOKEN(anon_sym_LReal); + END_STATE(); + case 462: + ACCEPT_TOKEN(anon_sym_LReal); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 463: + ACCEPT_TOKEN(anon_sym_lreal); + END_STATE(); + case 464: + ACCEPT_TOKEN(anon_sym_lreal); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 465: + ACCEPT_TOKEN(anon_sym_TIME); + END_STATE(); + case 466: + ACCEPT_TOKEN(anon_sym_TIME); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 467: + ACCEPT_TOKEN(anon_sym_Time); + END_STATE(); + case 468: + ACCEPT_TOKEN(anon_sym_Time); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 469: + ACCEPT_TOKEN(anon_sym_time); + END_STATE(); + case 470: + ACCEPT_TOKEN(anon_sym_time); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 471: + ACCEPT_TOKEN(anon_sym_TOD); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 472: + ACCEPT_TOKEN(anon_sym_Tod); + END_STATE(); + case 473: + ACCEPT_TOKEN(anon_sym_Tod); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 474: + ACCEPT_TOKEN(anon_sym_tod); + END_STATE(); + case 475: + ACCEPT_TOKEN(anon_sym_tod); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 476: + ACCEPT_TOKEN(anon_sym_DT); + END_STATE(); + case 477: + ACCEPT_TOKEN(anon_sym_DT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 478: + ACCEPT_TOKEN(anon_sym_Dt); + END_STATE(); + case 479: + ACCEPT_TOKEN(anon_sym_Dt); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 480: + ACCEPT_TOKEN(anon_sym_dt); + END_STATE(); + case 481: + ACCEPT_TOKEN(anon_sym_dt); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 482: + ACCEPT_TOKEN(anon_sym_String); + END_STATE(); + case 483: + ACCEPT_TOKEN(anon_sym_String); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 484: + ACCEPT_TOKEN(anon_sym_STRING); + END_STATE(); + case 485: + ACCEPT_TOKEN(anon_sym_STRING); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 486: + ACCEPT_TOKEN(anon_sym_string); + END_STATE(); + case 487: + ACCEPT_TOKEN(anon_sym_string); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 488: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 489: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 490: + ACCEPT_TOKEN(anon_sym_WString); + END_STATE(); + case 491: + ACCEPT_TOKEN(anon_sym_WString); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 492: + ACCEPT_TOKEN(anon_sym_WSTRING); + END_STATE(); + case 493: + ACCEPT_TOKEN(anon_sym_WSTRING); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 494: + ACCEPT_TOKEN(anon_sym_wstring); + END_STATE(); + case 495: + ACCEPT_TOKEN(anon_sym_wstring); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 496: + ACCEPT_TOKEN(anon_sym_Char); + END_STATE(); + case 497: + ACCEPT_TOKEN(anon_sym_Char); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 498: + ACCEPT_TOKEN(anon_sym_CHAR); + END_STATE(); + case 499: + ACCEPT_TOKEN(anon_sym_CHAR); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 500: + ACCEPT_TOKEN(anon_sym_char); + END_STATE(); + case 501: + ACCEPT_TOKEN(anon_sym_char); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 502: + ACCEPT_TOKEN(anon_sym_WChar); + END_STATE(); + case 503: + ACCEPT_TOKEN(anon_sym_WChar); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 504: + ACCEPT_TOKEN(anon_sym_WCHAR); + END_STATE(); + case 505: + ACCEPT_TOKEN(anon_sym_WCHAR); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 506: + ACCEPT_TOKEN(anon_sym_wchar); + END_STATE(); + case 507: + ACCEPT_TOKEN(anon_sym_wchar); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 508: + ACCEPT_TOKEN(anon_sym_ARRAY); + END_STATE(); + case 509: + ACCEPT_TOKEN(anon_sym_ARRAY); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 510: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + END_STATE(); + case 511: + ACCEPT_TOKEN(anon_sym_OF); + END_STATE(); + case 512: + ACCEPT_TOKEN(anon_sym_POUND); + END_STATE(); + case 513: + ACCEPT_TOKEN(anon_sym_DOT); + END_STATE(); + case 514: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(510); + END_STATE(); + case 515: + ACCEPT_TOKEN(anon_sym_IF); + END_STATE(); + case 516: + ACCEPT_TOKEN(anon_sym_IF); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 517: + ACCEPT_TOKEN(anon_sym_THEN); + END_STATE(); + case 518: + ACCEPT_TOKEN(anon_sym_END_IF); + END_STATE(); + case 519: + ACCEPT_TOKEN(anon_sym_END_IF); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 520: + ACCEPT_TOKEN(anon_sym_ELSIF); + END_STATE(); + case 521: + ACCEPT_TOKEN(anon_sym_ELSIF); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 522: + ACCEPT_TOKEN(anon_sym_ELSE); + END_STATE(); + case 523: + ACCEPT_TOKEN(anon_sym_ELSE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 524: + ACCEPT_TOKEN(anon_sym_CASE); + END_STATE(); + case 525: + ACCEPT_TOKEN(anon_sym_CASE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 526: + ACCEPT_TOKEN(anon_sym_END_CASE); + END_STATE(); + case 527: + ACCEPT_TOKEN(anon_sym_END_CASE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 528: + ACCEPT_TOKEN(anon_sym_FOR); + END_STATE(); + case 529: + ACCEPT_TOKEN(anon_sym_FOR); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 530: + ACCEPT_TOKEN(anon_sym_TO); + END_STATE(); + case 531: + ACCEPT_TOKEN(anon_sym_BY); + END_STATE(); + case 532: + ACCEPT_TOKEN(anon_sym_DO); + END_STATE(); + case 533: + ACCEPT_TOKEN(anon_sym_END_FOR); + END_STATE(); + case 534: + ACCEPT_TOKEN(anon_sym_END_FOR); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 535: + ACCEPT_TOKEN(anon_sym_WHILE); + END_STATE(); + case 536: + ACCEPT_TOKEN(anon_sym_WHILE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 537: + ACCEPT_TOKEN(anon_sym_END_WHILE); + END_STATE(); + case 538: + ACCEPT_TOKEN(anon_sym_END_WHILE); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 539: + ACCEPT_TOKEN(anon_sym_REPEAT); + END_STATE(); + case 540: + ACCEPT_TOKEN(anon_sym_REPEAT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 541: + ACCEPT_TOKEN(anon_sym_UNTIL); + END_STATE(); + case 542: + ACCEPT_TOKEN(anon_sym_UNTIL); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 543: + ACCEPT_TOKEN(anon_sym_END_REPEAT); + END_STATE(); + case 544: + ACCEPT_TOKEN(anon_sym_REGION); + END_STATE(); + case 545: + ACCEPT_TOKEN(anon_sym_REGION); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 546: + ACCEPT_TOKEN(anon_sym_END_REGION); + END_STATE(); + case 547: + ACCEPT_TOKEN(anon_sym_END_REGION); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 548: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(951); + END_STATE(); + case 549: + ACCEPT_TOKEN(anon_sym_DASH); + END_STATE(); + case 550: + ACCEPT_TOKEN(anon_sym_LPAREN); + if (lookahead == '*') ADVANCE(28); + if (lookahead == '/') ADVANCE(30); + END_STATE(); + case 551: + ACCEPT_TOKEN(anon_sym_EQ_GT); + END_STATE(); + case 552: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 553: + ACCEPT_TOKEN(anon_sym_NOT); + END_STATE(); + case 554: + ACCEPT_TOKEN(anon_sym_NOT); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 555: + ACCEPT_TOKEN(anon_sym_PLUS); + END_STATE(); + case 556: + ACCEPT_TOKEN(anon_sym_OR); + END_STATE(); + case 557: + ACCEPT_TOKEN(anon_sym_XOR); + END_STATE(); + case 558: + ACCEPT_TOKEN(anon_sym_AND); + END_STATE(); + case 559: + ACCEPT_TOKEN(anon_sym_LT_GT); + END_STATE(); + case 560: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '=') ADVANCE(562); + if (lookahead == '>') ADVANCE(559); + END_STATE(); + case 561: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(563); + END_STATE(); + case 562: + ACCEPT_TOKEN(anon_sym_LT_EQ); + END_STATE(); + case 563: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 564: + ACCEPT_TOKEN(anon_sym_STAR); + END_STATE(); + case 565: + ACCEPT_TOKEN(anon_sym_MOD); + END_STATE(); + case 566: + ACCEPT_TOKEN(sym_number); + if (lookahead == '#') ADVANCE(350); + if (lookahead == '.') ADVANCE(348); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + END_STATE(); + case 567: + ACCEPT_TOKEN(sym_number); + if (lookahead == '.') ADVANCE(348); + if (lookahead == '6') ADVANCE(566); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + END_STATE(); + case 568: + ACCEPT_TOKEN(sym_number); + if (lookahead == '.') ADVANCE(348); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(568); + END_STATE(); + case 569: + ACCEPT_TOKEN(sym_number); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(569); + END_STATE(); + case 570: + ACCEPT_TOKEN(sym_hex_number); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(570); + END_STATE(); + case 571: + ACCEPT_TOKEN(sym_time_value); + END_STATE(); + case 572: + ACCEPT_TOKEN(anon_sym_SQUOTE); + END_STATE(); + case 573: + ACCEPT_TOKEN(anon_sym_SQUOTE); + if (lookahead == '\'') ADVANCE(578); + END_STATE(); + case 574: + ACCEPT_TOKEN(aux_sym_string_token1); + END_STATE(); + case 575: + ACCEPT_TOKEN(aux_sym_string_token1); + if (lookahead == '(') ADVANCE(576); + if (lookahead == '/') ADVANCE(577); + if (lookahead == '\t' || + (0x0b <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(575); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != '\'' && + lookahead != '(') ADVANCE(574); + END_STATE(); + case 576: + ACCEPT_TOKEN(aux_sym_string_token1); + if (lookahead == '*') ADVANCE(28); + if (lookahead == '/') ADVANCE(30); + END_STATE(); + case 577: + ACCEPT_TOKEN(aux_sym_string_token1); + if (lookahead == '/') ADVANCE(951); + END_STATE(); + case 578: + ACCEPT_TOKEN(anon_sym_SQUOTE_SQUOTE); + END_STATE(); + case 579: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 580: + ACCEPT_TOKEN(anon_sym_DQUOTE); + if (lookahead == '"') ADVANCE(585); + END_STATE(); + case 581: + ACCEPT_TOKEN(aux_sym_string_token2); + END_STATE(); + case 582: + ACCEPT_TOKEN(aux_sym_string_token2); + if (lookahead == '(') ADVANCE(583); + if (lookahead == '/') ADVANCE(584); + if (lookahead == '\t' || + (0x0b <= lookahead && lookahead <= '\r') || + lookahead == ' ') ADVANCE(582); + if (lookahead != 0 && + (lookahead < '\t' || '\r' < lookahead) && + lookahead != '"') ADVANCE(581); + END_STATE(); + case 583: + ACCEPT_TOKEN(aux_sym_string_token2); + if (lookahead == '*') ADVANCE(28); + if (lookahead == '/') ADVANCE(30); + END_STATE(); + case 584: + ACCEPT_TOKEN(aux_sym_string_token2); + if (lookahead == '/') ADVANCE(951); + END_STATE(); + case 585: + ACCEPT_TOKEN(anon_sym_DQUOTE_DQUOTE); + END_STATE(); + case 586: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '#') ADVANCE(349); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 587: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(806); + if (lookahead == 'O') ADVANCE(717); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 588: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(852); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 589: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(788); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 590: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(735); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 591: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(813); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 592: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(702); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 593: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(703); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 594: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(679); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 595: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(714); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 596: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(789); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 597: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(790); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 598: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(792); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 599: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(741); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 600: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(680); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 601: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(809); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 602: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(749); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 603: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(683); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 604: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(684); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 605: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(835); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 606: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(839); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 607: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A') ADVANCE(757); + if (('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 608: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'B') ADVANCE(706); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 609: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'B') ADVANCE(708); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 610: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'B') ADVANCE(709); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 611: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'B') ADVANCE(710); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 612: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(697); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 613: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(698); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 614: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(699); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 615: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(700); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 616: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(601); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 617: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(831); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 618: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(768); + if (lookahead == 'I') ADVANCE(720); + if (lookahead == 'N') ADVANCE(769); + if (lookahead == 'O') ADVANCE(841); + if (lookahead == 'R') ADVANCE(649); + if (lookahead == 'T') ADVANCE(637); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 619: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(670); + if (lookahead == 'O') ADVANCE(793); + if (lookahead == 'S') ADVANCE(834); + if (lookahead == 'o') ADVANCE(928); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 620: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(838); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 621: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C') ADVANCE(840); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 622: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(471); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 623: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(437); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 624: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(443); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 625: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(862); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 626: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(859); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 627: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(857); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 628: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(861); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 629: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(860); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 630: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(855); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 631: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(856); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 632: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(863); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 633: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D') ADVANCE(868); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 634: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(664); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 635: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(525); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 636: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(536); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 637: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(715); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 638: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(957); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 639: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(448); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 640: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(466); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 641: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(523); + if (lookahead == 'I') ADVANCE(656); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 642: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(523); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 643: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(527); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 644: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(538); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 645: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(375); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 646: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(377); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 647: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(591); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 648: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(665); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 649: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(827); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 650: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(592); + if (lookahead == 'e') ADVANCE(869); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 651: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(593); + if (lookahead == 'e') ADVANCE(872); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 652: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(832); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 653: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(836); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 654: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E') ADVANCE(837); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 655: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F') ADVANCE(516); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 656: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F') ADVANCE(521); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 657: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F') ADVANCE(519); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 658: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F') ADVANCE(847); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 659: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F') ADVANCE(773); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 660: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F') ADVANCE(848); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 661: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G') ADVANCE(485); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 662: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G') ADVANCE(493); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 663: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G') ADVANCE(590); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 664: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G') ADVANCE(672); + if (lookahead == 'P') ADVANCE(647); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 665: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G') ADVANCE(692); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 666: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G') ADVANCE(607); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 667: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'H') ADVANCE(671); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 668: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'H') ADVANCE(596); + if (lookahead == 'h') ADVANCE(871); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 669: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'H') ADVANCE(685); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 670: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'H') ADVANCE(597); + if (lookahead == 'h') ADVANCE(875); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 671: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(707); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 672: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(764); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 673: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(853); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 674: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(812); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 675: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(716); + if (lookahead == 'O') ADVANCE(622); + if (lookahead == 'i') ADVANCE(910); + if (lookahead == 'o') ADVANCE(878); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 676: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(657); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 677: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(731); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 678: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(704); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 679: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(723); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 680: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(724); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 681: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(730); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 682: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(733); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 683: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(727); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 684: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(728); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 685: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(711); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 686: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(745); + if (lookahead == 'T') ADVANCE(477); + if (lookahead == 'W') ADVANCE(771); + if (lookahead == 't') ADVANCE(479); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 687: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(746); + if (lookahead == 'T') ADVANCE(800); + if (lookahead == 't') ADVANCE(927); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 688: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(770); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 689: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(747); + if (lookahead == 'S') ADVANCE(691); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 690: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(772); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 691: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(748); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 692: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(774); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 693: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(775); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 694: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(779); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 695: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(780); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 696: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I') ADVANCE(854); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 697: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'K') ADVANCE(363); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 698: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'K') ADVANCE(353); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 699: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'K') ADVANCE(361); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 700: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'K') ADVANCE(364); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 701: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(403); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 702: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(454); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 703: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(460); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 704: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(542); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 705: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(805); + if (lookahead == 'N') ADVANCE(625); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 706: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(761); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 707: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(636); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 708: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(762); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 709: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(765); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 710: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(767); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 711: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(644); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 712: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(808); + if (lookahead == 'N') ADVANCE(626); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 713: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(808); + if (lookahead == 'N') ADVANCE(626); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 714: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'L') ADVANCE(810); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 715: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'M') ADVANCE(783); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 716: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'M') ADVANCE(640); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 717: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(826); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 718: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(617); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 719: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(545); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 720: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(784); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 721: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(858); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 722: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(366); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 723: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(397); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 724: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(399); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 725: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(547); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 726: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(368); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 727: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(391); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 728: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(393); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 729: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(807); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 730: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(661); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 731: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(842); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 732: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(864); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 733: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(662); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 734: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(625); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 735: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(673); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 736: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(626); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 737: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(632); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 738: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(627); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 739: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(628); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 740: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(629); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 741: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(818); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 742: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(630); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 743: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(631); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 744: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(819); + if (lookahead == 'n') ADVANCE(936); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 745: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(820); + if (lookahead == 'n') ADVANCE(938); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 746: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(821); + if (lookahead == 'n') ADVANCE(939); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 747: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(822); + if (lookahead == 'n') ADVANCE(940); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 748: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(823); + if (lookahead == 'n') ADVANCE(944); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 749: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(825); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 750: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(830); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 751: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(811); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 752: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(865); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 753: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(866); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 754: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(620); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 755: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(621); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 756: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(867); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 757: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(696); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 758: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N') ADVANCE(633); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 759: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(787); + if (lookahead == 'U') ADVANCE(718); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 760: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(787); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 761: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(612); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 762: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(613); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 763: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(701); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 764: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(719); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 765: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(614); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 766: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(763); + if (lookahead == 'Y') ADVANCE(829); + if (lookahead == 'o') ADVANCE(921); + if (lookahead == 'y') ADVANCE(946); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 767: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(615); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 768: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(729); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 769: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(721); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 770: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(722); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 771: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(794); + if (lookahead == 'o') ADVANCE(932); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 772: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(732); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 773: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(791); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 774: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(725); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 775: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(726); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 776: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(824); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 777: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(844); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 778: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(751); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 779: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(752); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 780: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(753); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 781: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(756); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 782: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O') ADVANCE(804); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 783: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'P') ADVANCE(387); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 784: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'P') ADVANCE(843); + if (lookahead == '_') ADVANCE(777); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 785: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'P') ADVANCE(845); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 786: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(663); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 787: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(529); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 788: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(385); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 789: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(499); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 790: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(505); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 791: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(534); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 792: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(401); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 793: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(623); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 794: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(624); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 795: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(796); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 796: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(588); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 797: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(648); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 798: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(651); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 799: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(846); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 800: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(681); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 801: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(682); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 802: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(652); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 803: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(654); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 804: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R') ADVANCE(666); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 805: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(641); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 806: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(635); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 807: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(828); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 808: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(642); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 809: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(643); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 810: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(646); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 811: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'S') ADVANCE(833); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 812: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(955); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 813: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(540); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 814: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(785); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 815: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(379); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 816: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(383); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 817: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(381); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 818: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(395); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 819: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(407); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 820: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(413); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 821: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(419); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 822: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(431); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 823: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(425); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 824: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(554); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 825: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(389); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 826: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(677); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 827: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(594); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 828: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(599); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 829: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(639); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 830: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(678); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 831: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(688); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 832: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(600); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 833: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(602); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 834: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(801); + if (lookahead == 't') ADVANCE(931); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 835: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(690); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 836: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(603); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 837: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(604); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 838: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(693); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 839: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(694); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 840: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'T') ADVANCE(695); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 841: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(814); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 842: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(638); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 843: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(815); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 844: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(816); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 845: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(817); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 846: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(645); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 847: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(754); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 848: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U') ADVANCE(755); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 849: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'V') ADVANCE(598); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 850: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'W') ADVANCE(669); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 851: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'X') ADVANCE(674); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 852: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'Y') ADVANCE(509); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 853: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'Z') ADVANCE(605); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Y') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 854: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'Z') ADVANCE(606); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Y') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 855: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(850); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 856: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(849); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 857: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(658); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 858: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(802); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 859: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(616); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 860: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(659); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 861: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(782); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 862: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(676); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 863: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(797); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 864: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(609); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 865: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(610); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 866: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(611); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 867: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(803); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 868: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '_') ADVANCE(660); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 869: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(906); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 870: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(907); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 871: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(923); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 872: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(908); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 873: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(924); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 874: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(909); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 875: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(925); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 876: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'a') ADVANCE(926); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 877: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'c') ADVANCE(895); + if (lookahead == 'o') ADVANCE(930); + if (lookahead == 's') ADVANCE(948); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 878: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'd') ADVANCE(473); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 879: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'd') ADVANCE(475); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 880: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'd') ADVANCE(439); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 881: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'd') ADVANCE(441); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 882: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'd') ADVANCE(445); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 883: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'd') ADVANCE(447); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 884: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'e') ADVANCE(450); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 885: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'e') ADVANCE(468); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 886: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'e') ADVANCE(452); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 887: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'e') ADVANCE(470); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 888: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'e') ADVANCE(870); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 889: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'e') ADVANCE(874); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 890: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'g') ADVANCE(483); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 891: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'g') ADVANCE(487); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 892: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'g') ADVANCE(491); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 893: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'g') ADVANCE(495); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 894: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'h') ADVANCE(873); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 895: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'h') ADVANCE(876); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 896: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(912); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 897: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(913); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 898: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(915); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 899: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(916); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 900: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(917); + if (lookahead == 't') ADVANCE(481); + if (lookahead == 'w') ADVANCE(922); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 901: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(911); + if (lookahead == 'o') ADVANCE(879); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 902: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(918); + if (lookahead == 't') ADVANCE(929); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 903: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(919); + if (lookahead == 's') ADVANCE(904); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 904: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'i') ADVANCE(920); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 905: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'l') ADVANCE(405); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 906: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'l') ADVANCE(456); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 907: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'l') ADVANCE(458); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 908: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'l') ADVANCE(462); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 909: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'l') ADVANCE(464); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 910: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'm') ADVANCE(885); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 911: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'm') ADVANCE(887); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 912: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(890); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 913: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(891); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 914: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(937); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 915: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(892); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 916: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(893); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 917: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(941); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 918: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(942); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 919: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(943); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 920: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'n') ADVANCE(945); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 921: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'o') ADVANCE(905); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 922: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'o') ADVANCE(934); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 923: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(497); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 924: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(501); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 925: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(503); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 926: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(507); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 927: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(896); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 928: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(880); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 929: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(897); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 930: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(881); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 931: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(898); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 932: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(882); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 933: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(899); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 934: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(883); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 935: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'r') ADVANCE(889); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 936: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(409); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 937: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(411); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 938: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(415); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 939: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(421); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 940: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(433); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 941: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(417); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 942: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(423); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 943: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(435); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 944: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(427); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 945: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(429); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 946: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(884); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 947: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(886); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 948: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 't') ADVANCE(933); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 949: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'y') ADVANCE(947); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 950: + ACCEPT_TOKEN(sym_identifier); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 951: + ACCEPT_TOKEN(sym_line_comment); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(951); + END_STATE(); + case 952: + ACCEPT_TOKEN(sym_block_comment); + END_STATE(); + case 953: + ACCEPT_TOKEN(sym_c_style_comment); + if (lookahead == '*') ADVANCE(33); + if (lookahead != 0) ADVANCE(29); + END_STATE(); + case 954: + ACCEPT_TOKEN(sym_exit_statement); + END_STATE(); + case 955: + ACCEPT_TOKEN(sym_exit_statement); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + case 956: + ACCEPT_TOKEN(sym_continue_statement); + END_STATE(); + case 957: + ACCEPT_TOKEN(sym_continue_statement); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(950); + END_STATE(); + default: + return false; + } +} + +static const TSLexerMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0}, + [1] = {.lex_state = 351}, + [2] = {.lex_state = 16}, + [3] = {.lex_state = 16}, + [4] = {.lex_state = 16}, + [5] = {.lex_state = 16}, + [6] = {.lex_state = 16}, + [7] = {.lex_state = 351}, + [8] = {.lex_state = 351}, + [9] = {.lex_state = 6}, + [10] = {.lex_state = 6}, + [11] = {.lex_state = 6}, + [12] = {.lex_state = 6}, + [13] = {.lex_state = 6}, + [14] = {.lex_state = 6}, + [15] = {.lex_state = 6}, + [16] = {.lex_state = 6}, + [17] = {.lex_state = 6}, + [18] = {.lex_state = 6}, + [19] = {.lex_state = 6}, + [20] = {.lex_state = 6}, + [21] = {.lex_state = 6}, + [22] = {.lex_state = 6}, + [23] = {.lex_state = 6}, + [24] = {.lex_state = 6}, + [25] = {.lex_state = 6}, + [26] = {.lex_state = 6}, + [27] = {.lex_state = 6}, + [28] = {.lex_state = 6}, + [29] = {.lex_state = 6}, + [30] = {.lex_state = 6}, + [31] = {.lex_state = 6}, + [32] = {.lex_state = 6}, + [33] = {.lex_state = 8}, + [34] = {.lex_state = 6}, + [35] = {.lex_state = 8}, + [36] = {.lex_state = 6}, + [37] = {.lex_state = 6}, + [38] = {.lex_state = 8}, + [39] = {.lex_state = 7}, + [40] = {.lex_state = 9}, + [41] = {.lex_state = 10}, + [42] = {.lex_state = 11}, + [43] = {.lex_state = 11}, + [44] = {.lex_state = 15}, + [45] = {.lex_state = 15}, + [46] = {.lex_state = 9}, + [47] = {.lex_state = 9}, + [48] = {.lex_state = 11}, + [49] = {.lex_state = 11}, + [50] = {.lex_state = 15}, + [51] = {.lex_state = 15}, + [52] = {.lex_state = 9}, + [53] = {.lex_state = 9}, + [54] = {.lex_state = 11}, + [55] = {.lex_state = 12}, + [56] = {.lex_state = 11}, + [57] = {.lex_state = 11}, + [58] = {.lex_state = 15}, + [59] = {.lex_state = 15}, + [60] = {.lex_state = 9}, + [61] = {.lex_state = 9}, + [62] = {.lex_state = 12}, + [63] = {.lex_state = 11}, + [64] = {.lex_state = 11}, + [65] = {.lex_state = 15}, + [66] = {.lex_state = 15}, + [67] = {.lex_state = 9}, + [68] = {.lex_state = 9}, + [69] = {.lex_state = 12}, + [70] = {.lex_state = 11}, + [71] = {.lex_state = 11}, + [72] = {.lex_state = 15}, + [73] = {.lex_state = 15}, + [74] = {.lex_state = 9}, + [75] = {.lex_state = 9}, + [76] = {.lex_state = 15}, + [77] = {.lex_state = 12}, + [78] = {.lex_state = 11}, + [79] = {.lex_state = 11}, + [80] = {.lex_state = 15}, + [81] = {.lex_state = 15}, + [82] = {.lex_state = 9}, + [83] = {.lex_state = 9}, + [84] = {.lex_state = 11}, + [85] = {.lex_state = 15}, + [86] = {.lex_state = 9}, + [87] = {.lex_state = 9}, + [88] = {.lex_state = 9}, + [89] = {.lex_state = 9}, + [90] = {.lex_state = 9}, + [91] = {.lex_state = 7}, + [92] = {.lex_state = 13}, + [93] = {.lex_state = 13}, + [94] = {.lex_state = 11}, + [95] = {.lex_state = 15}, + [96] = {.lex_state = 9}, + [97] = {.lex_state = 9}, + [98] = {.lex_state = 14}, + [99] = {.lex_state = 10}, + [100] = {.lex_state = 13}, + [101] = {.lex_state = 12}, + [102] = {.lex_state = 7}, + [103] = {.lex_state = 14}, + [104] = {.lex_state = 14}, + [105] = {.lex_state = 7}, + [106] = {.lex_state = 5}, + [107] = {.lex_state = 14}, + [108] = {.lex_state = 12}, + [109] = {.lex_state = 12}, + [110] = {.lex_state = 12}, + [111] = {.lex_state = 12}, + [112] = {.lex_state = 7}, + [113] = {.lex_state = 14}, + [114] = {.lex_state = 5}, + [115] = {.lex_state = 7}, + [116] = {.lex_state = 14}, + [117] = {.lex_state = 12}, + [118] = {.lex_state = 9}, + [119] = {.lex_state = 12}, + [120] = {.lex_state = 12}, + [121] = {.lex_state = 7}, + [122] = {.lex_state = 14}, + [123] = {.lex_state = 7}, + [124] = {.lex_state = 14}, + [125] = {.lex_state = 12}, + [126] = {.lex_state = 12}, + [127] = {.lex_state = 12}, + [128] = {.lex_state = 12}, + [129] = {.lex_state = 7}, + [130] = {.lex_state = 14}, + [131] = {.lex_state = 7}, + [132] = {.lex_state = 11}, + [133] = {.lex_state = 14}, + [134] = {.lex_state = 12}, + [135] = {.lex_state = 12}, + [136] = {.lex_state = 12}, + [137] = {.lex_state = 12}, + [138] = {.lex_state = 7}, + [139] = {.lex_state = 11}, + [140] = {.lex_state = 14}, + [141] = {.lex_state = 7}, + [142] = {.lex_state = 15}, + [143] = {.lex_state = 14}, + [144] = {.lex_state = 12}, + [145] = {.lex_state = 12}, + [146] = {.lex_state = 12}, + [147] = {.lex_state = 12}, + [148] = {.lex_state = 7}, + [149] = {.lex_state = 15}, + [150] = {.lex_state = 14}, + [151] = {.lex_state = 7}, + [152] = {.lex_state = 9}, + [153] = {.lex_state = 14}, + [154] = {.lex_state = 12}, + [155] = {.lex_state = 12}, + [156] = {.lex_state = 12}, + [157] = {.lex_state = 12}, + [158] = {.lex_state = 7}, + [159] = {.lex_state = 9}, + [160] = {.lex_state = 14}, + [161] = {.lex_state = 7}, + [162] = {.lex_state = 5}, + [163] = {.lex_state = 14}, + [164] = {.lex_state = 12}, + [165] = {.lex_state = 12}, + [166] = {.lex_state = 12}, + [167] = {.lex_state = 12}, + [168] = {.lex_state = 7}, + [169] = {.lex_state = 10}, + [170] = {.lex_state = 14}, + [171] = {.lex_state = 7}, + [172] = {.lex_state = 7}, + [173] = {.lex_state = 14}, + [174] = {.lex_state = 12}, + [175] = {.lex_state = 12}, + [176] = {.lex_state = 12}, + [177] = {.lex_state = 12}, + [178] = {.lex_state = 7}, + [179] = {.lex_state = 14}, + [180] = {.lex_state = 14}, + [181] = {.lex_state = 7}, + [182] = {.lex_state = 14}, + [183] = {.lex_state = 12}, + [184] = {.lex_state = 12}, + [185] = {.lex_state = 12}, + [186] = {.lex_state = 12}, + [187] = {.lex_state = 7}, + [188] = {.lex_state = 14}, + [189] = {.lex_state = 7}, + [190] = {.lex_state = 11}, + [191] = {.lex_state = 14}, + [192] = {.lex_state = 12}, + [193] = {.lex_state = 12}, + [194] = {.lex_state = 12}, + [195] = {.lex_state = 12}, + [196] = {.lex_state = 7}, + [197] = {.lex_state = 11}, + [198] = {.lex_state = 14}, + [199] = {.lex_state = 7}, + [200] = {.lex_state = 15}, + [201] = {.lex_state = 14}, + [202] = {.lex_state = 12}, + [203] = {.lex_state = 12}, + [204] = {.lex_state = 12}, + [205] = {.lex_state = 12}, + [206] = {.lex_state = 15}, + [207] = {.lex_state = 5}, + [208] = {.lex_state = 5}, + [209] = {.lex_state = 5}, + [210] = {.lex_state = 5}, + [211] = {.lex_state = 5}, + [212] = {.lex_state = 5}, + [213] = {.lex_state = 5}, + [214] = {.lex_state = 5}, + [215] = {.lex_state = 5}, + [216] = {.lex_state = 5}, + [217] = {.lex_state = 5}, + [218] = {.lex_state = 5}, + [219] = {.lex_state = 5}, + [220] = {.lex_state = 5}, + [221] = {.lex_state = 5}, + [222] = {.lex_state = 5}, + [223] = {.lex_state = 5}, + [224] = {.lex_state = 5}, + [225] = {.lex_state = 5}, + [226] = {.lex_state = 5}, + [227] = {.lex_state = 5}, + [228] = {.lex_state = 5}, + [229] = {.lex_state = 12}, + [230] = {.lex_state = 20}, + [231] = {.lex_state = 20}, + [232] = {.lex_state = 351}, + [233] = {.lex_state = 351}, + [234] = {.lex_state = 351}, + [235] = {.lex_state = 6}, + [236] = {.lex_state = 21}, + [237] = {.lex_state = 6}, + [238] = {.lex_state = 8}, + [239] = {.lex_state = 8}, + [240] = {.lex_state = 351}, + [241] = {.lex_state = 6}, + [242] = {.lex_state = 6}, + [243] = {.lex_state = 8}, + [244] = {.lex_state = 20}, + [245] = {.lex_state = 20}, + [246] = {.lex_state = 8}, + [247] = {.lex_state = 20}, + [248] = {.lex_state = 20}, + [249] = {.lex_state = 10}, + [250] = {.lex_state = 5}, + [251] = {.lex_state = 20}, + [252] = {.lex_state = 13}, + [253] = {.lex_state = 15}, + [254] = {.lex_state = 13}, + [255] = {.lex_state = 9}, + [256] = {.lex_state = 9}, + [257] = {.lex_state = 15}, + [258] = {.lex_state = 5}, + [259] = {.lex_state = 14}, + [260] = {.lex_state = 12}, + [261] = {.lex_state = 12}, + [262] = {.lex_state = 14}, + [263] = {.lex_state = 10}, + [264] = {.lex_state = 7}, + [265] = {.lex_state = 7}, + [266] = {.lex_state = 351}, + [267] = {.lex_state = 11}, + [268] = {.lex_state = 11}, + [269] = {.lex_state = 351}, + [270] = {.lex_state = 8}, + [271] = {.lex_state = 10}, + [272] = {.lex_state = 6}, + [273] = {.lex_state = 7}, + [274] = {.lex_state = 7}, + [275] = {.lex_state = 12}, + [276] = {.lex_state = 10}, + [277] = {.lex_state = 12}, + [278] = {.lex_state = 6}, + [279] = {.lex_state = 14}, + [280] = {.lex_state = 8}, + [281] = {.lex_state = 5}, + [282] = {.lex_state = 13}, + [283] = {.lex_state = 9}, + [284] = {.lex_state = 5}, + [285] = {.lex_state = 9}, + [286] = {.lex_state = 11}, + [287] = {.lex_state = 13}, + [288] = {.lex_state = 15}, + [289] = {.lex_state = 14}, + [290] = {.lex_state = 11}, + [291] = {.lex_state = 15}, + [292] = {.lex_state = 351}, + [293] = {.lex_state = 351}, + [294] = {.lex_state = 351}, + [295] = {.lex_state = 351}, + [296] = {.lex_state = 351}, + [297] = {.lex_state = 351}, + [298] = {.lex_state = 351}, + [299] = {.lex_state = 351}, + [300] = {.lex_state = 351}, + [301] = {.lex_state = 351}, + [302] = {.lex_state = 351}, + [303] = {.lex_state = 351}, + [304] = {.lex_state = 351}, + [305] = {.lex_state = 351}, + [306] = {.lex_state = 0}, + [307] = {.lex_state = 0}, + [308] = {.lex_state = 351}, + [309] = {.lex_state = 351}, + [310] = {.lex_state = 351}, + [311] = {.lex_state = 351}, + [312] = {.lex_state = 351}, + [313] = {.lex_state = 351}, + [314] = {.lex_state = 351}, + [315] = {.lex_state = 351}, + [316] = {.lex_state = 351}, + [317] = {.lex_state = 351}, + [318] = {.lex_state = 351}, + [319] = {.lex_state = 351}, + [320] = {.lex_state = 0}, + [321] = {.lex_state = 0}, + [322] = {.lex_state = 351}, + [323] = {.lex_state = 0}, + [324] = {.lex_state = 351}, + [325] = {.lex_state = 0}, + [326] = {.lex_state = 351}, + [327] = {.lex_state = 351}, + [328] = {.lex_state = 0}, + [329] = {.lex_state = 351}, + [330] = {.lex_state = 351}, + [331] = {.lex_state = 351}, + [332] = {.lex_state = 351}, + [333] = {.lex_state = 351}, + [334] = {.lex_state = 0}, + [335] = {.lex_state = 0}, + [336] = {.lex_state = 351}, + [337] = {.lex_state = 351}, + [338] = {.lex_state = 351}, + [339] = {.lex_state = 0}, + [340] = {.lex_state = 351}, + [341] = {.lex_state = 0}, + [342] = {.lex_state = 0}, + [343] = {.lex_state = 351}, + [344] = {.lex_state = 351}, + [345] = {.lex_state = 351}, + [346] = {.lex_state = 351}, + [347] = {.lex_state = 351}, + [348] = {.lex_state = 351}, + [349] = {.lex_state = 351}, + [350] = {.lex_state = 351}, + [351] = {.lex_state = 351}, + [352] = {.lex_state = 351}, + [353] = {.lex_state = 351}, + [354] = {.lex_state = 351}, + [355] = {.lex_state = 351}, + [356] = {.lex_state = 351}, + [357] = {.lex_state = 351}, + [358] = {.lex_state = 351}, + [359] = {.lex_state = 351}, + [360] = {.lex_state = 351}, + [361] = {.lex_state = 351}, + [362] = {.lex_state = 351}, + [363] = {.lex_state = 351}, + [364] = {.lex_state = 351}, + [365] = {.lex_state = 351}, + [366] = {.lex_state = 351}, + [367] = {.lex_state = 351}, + [368] = {.lex_state = 351}, + [369] = {.lex_state = 351}, + [370] = {.lex_state = 351}, + [371] = {.lex_state = 351}, + [372] = {.lex_state = 351}, + [373] = {.lex_state = 351}, + [374] = {.lex_state = 351}, + [375] = {.lex_state = 0}, + [376] = {.lex_state = 6}, + [377] = {.lex_state = 8}, + [378] = {.lex_state = 8}, + [379] = {.lex_state = 8}, + [380] = {.lex_state = 5}, + [381] = {.lex_state = 8}, + [382] = {.lex_state = 8}, + [383] = {.lex_state = 8}, + [384] = {.lex_state = 5}, + [385] = {.lex_state = 8}, + [386] = {.lex_state = 8}, + [387] = {.lex_state = 11}, + [388] = {.lex_state = 8}, + [389] = {.lex_state = 8}, + [390] = {.lex_state = 8}, + [391] = {.lex_state = 11}, + [392] = {.lex_state = 8}, + [393] = {.lex_state = 6}, + [394] = {.lex_state = 8}, + [395] = {.lex_state = 8}, + [396] = {.lex_state = 15}, + [397] = {.lex_state = 8}, + [398] = {.lex_state = 8}, + [399] = {.lex_state = 8}, + [400] = {.lex_state = 15}, + [401] = {.lex_state = 6}, + [402] = {.lex_state = 6}, + [403] = {.lex_state = 6}, + [404] = {.lex_state = 6}, + [405] = {.lex_state = 6}, + [406] = {.lex_state = 13}, + [407] = {.lex_state = 6}, + [408] = {.lex_state = 6}, + [409] = {.lex_state = 6}, + [410] = {.lex_state = 6}, + [411] = {.lex_state = 6}, + [412] = {.lex_state = 6}, + [413] = {.lex_state = 6}, + [414] = {.lex_state = 6}, + [415] = {.lex_state = 6}, + [416] = {.lex_state = 6}, + [417] = {.lex_state = 6}, + [418] = {.lex_state = 6}, + [419] = {.lex_state = 6}, + [420] = {.lex_state = 6}, + [421] = {.lex_state = 6}, + [422] = {.lex_state = 6}, + [423] = {.lex_state = 6}, + [424] = {.lex_state = 8}, + [425] = {.lex_state = 6}, + [426] = {.lex_state = 6}, + [427] = {.lex_state = 8}, + [428] = {.lex_state = 9}, + [429] = {.lex_state = 6}, + [430] = {.lex_state = 6}, + [431] = {.lex_state = 6}, + [432] = {.lex_state = 6}, + [433] = {.lex_state = 8}, + [434] = {.lex_state = 8}, + [435] = {.lex_state = 8}, + [436] = {.lex_state = 9}, + [437] = {.lex_state = 6}, + [438] = {.lex_state = 6}, + [439] = {.lex_state = 6}, + [440] = {.lex_state = 6}, + [441] = {.lex_state = 8}, + [442] = {.lex_state = 6}, + [443] = {.lex_state = 6}, + [444] = {.lex_state = 6}, + [445] = {.lex_state = 8}, + [446] = {.lex_state = 13}, + [447] = {.lex_state = 6}, + [448] = {.lex_state = 8}, + [449] = {.lex_state = 8}, + [450] = {.lex_state = 8}, + [451] = {.lex_state = 8}, + [452] = {.lex_state = 7}, + [453] = {.lex_state = 8}, + [454] = {.lex_state = 14}, + [455] = {.lex_state = 8}, + [456] = {.lex_state = 8}, + [457] = {.lex_state = 7}, + [458] = {.lex_state = 14}, + [459] = {.lex_state = 8}, + [460] = {.lex_state = 8}, + [461] = {.lex_state = 8}, + [462] = {.lex_state = 8}, + [463] = {.lex_state = 8}, + [464] = {.lex_state = 10}, + [465] = {.lex_state = 8}, + [466] = {.lex_state = 12}, + [467] = {.lex_state = 12}, + [468] = {.lex_state = 10}, + [469] = {.lex_state = 8}, + [470] = {.lex_state = 8}, + [471] = {.lex_state = 6}, + [472] = {.lex_state = 13}, + [473] = {.lex_state = 9}, + [474] = {.lex_state = 5}, + [475] = {.lex_state = 5}, + [476] = {.lex_state = 5}, + [477] = {.lex_state = 5}, + [478] = {.lex_state = 5}, + [479] = {.lex_state = 9}, + [480] = {.lex_state = 5}, + [481] = {.lex_state = 5}, + [482] = {.lex_state = 5}, + [483] = {.lex_state = 5}, + [484] = {.lex_state = 7}, + [485] = {.lex_state = 7}, + [486] = {.lex_state = 14}, + [487] = {.lex_state = 14}, + [488] = {.lex_state = 14}, + [489] = {.lex_state = 14}, + [490] = {.lex_state = 14}, + [491] = {.lex_state = 5}, + [492] = {.lex_state = 14}, + [493] = {.lex_state = 14}, + [494] = {.lex_state = 14}, + [495] = {.lex_state = 14}, + [496] = {.lex_state = 14}, + [497] = {.lex_state = 14}, + [498] = {.lex_state = 14}, + [499] = {.lex_state = 14}, + [500] = {.lex_state = 14}, + [501] = {.lex_state = 14}, + [502] = {.lex_state = 7}, + [503] = {.lex_state = 14}, + [504] = {.lex_state = 14}, + [505] = {.lex_state = 14}, + [506] = {.lex_state = 14}, + [507] = {.lex_state = 14}, + [508] = {.lex_state = 14}, + [509] = {.lex_state = 10}, + [510] = {.lex_state = 10}, + [511] = {.lex_state = 7}, + [512] = {.lex_state = 14}, + [513] = {.lex_state = 14}, + [514] = {.lex_state = 14}, + [515] = {.lex_state = 14}, + [516] = {.lex_state = 7}, + [517] = {.lex_state = 7}, + [518] = {.lex_state = 7}, + [519] = {.lex_state = 14}, + [520] = {.lex_state = 14}, + [521] = {.lex_state = 14}, + [522] = {.lex_state = 14}, + [523] = {.lex_state = 5}, + [524] = {.lex_state = 7}, + [525] = {.lex_state = 7}, + [526] = {.lex_state = 14}, + [527] = {.lex_state = 14}, + [528] = {.lex_state = 14}, + [529] = {.lex_state = 14}, + [530] = {.lex_state = 10}, + [531] = {.lex_state = 10}, + [532] = {.lex_state = 10}, + [533] = {.lex_state = 10}, + [534] = {.lex_state = 10}, + [535] = {.lex_state = 7}, + [536] = {.lex_state = 14}, + [537] = {.lex_state = 10}, + [538] = {.lex_state = 10}, + [539] = {.lex_state = 10}, + [540] = {.lex_state = 10}, + [541] = {.lex_state = 10}, + [542] = {.lex_state = 10}, + [543] = {.lex_state = 10}, + [544] = {.lex_state = 10}, + [545] = {.lex_state = 10}, + [546] = {.lex_state = 10}, + [547] = {.lex_state = 14}, + [548] = {.lex_state = 10}, + [549] = {.lex_state = 10}, + [550] = {.lex_state = 10}, + [551] = {.lex_state = 10}, + [552] = {.lex_state = 10}, + [553] = {.lex_state = 10}, + [554] = {.lex_state = 13}, + [555] = {.lex_state = 13}, + [556] = {.lex_state = 14}, + [557] = {.lex_state = 10}, + [558] = {.lex_state = 10}, + [559] = {.lex_state = 10}, + [560] = {.lex_state = 10}, + [561] = {.lex_state = 7}, + [562] = {.lex_state = 7}, + [563] = {.lex_state = 14}, + [564] = {.lex_state = 10}, + [565] = {.lex_state = 10}, + [566] = {.lex_state = 10}, + [567] = {.lex_state = 10}, + [568] = {.lex_state = 7}, + [569] = {.lex_state = 7}, + [570] = {.lex_state = 7}, + [571] = {.lex_state = 7}, + [572] = {.lex_state = 10}, + [573] = {.lex_state = 10}, + [574] = {.lex_state = 10}, + [575] = {.lex_state = 10}, + [576] = {.lex_state = 13}, + [577] = {.lex_state = 13}, + [578] = {.lex_state = 13}, + [579] = {.lex_state = 7}, + [580] = {.lex_state = 13}, + [581] = {.lex_state = 5}, + [582] = {.lex_state = 10}, + [583] = {.lex_state = 13}, + [584] = {.lex_state = 13}, + [585] = {.lex_state = 13}, + [586] = {.lex_state = 13}, + [587] = {.lex_state = 13}, + [588] = {.lex_state = 13}, + [589] = {.lex_state = 13}, + [590] = {.lex_state = 13}, + [591] = {.lex_state = 13}, + [592] = {.lex_state = 13}, + [593] = {.lex_state = 10}, + [594] = {.lex_state = 13}, + [595] = {.lex_state = 13}, + [596] = {.lex_state = 13}, + [597] = {.lex_state = 13}, + [598] = {.lex_state = 13}, + [599] = {.lex_state = 13}, + [600] = {.lex_state = 7}, + [601] = {.lex_state = 7}, + [602] = {.lex_state = 10}, + [603] = {.lex_state = 13}, + [604] = {.lex_state = 13}, + [605] = {.lex_state = 13}, + [606] = {.lex_state = 13}, + [607] = {.lex_state = 7}, + [608] = {.lex_state = 7}, + [609] = {.lex_state = 10}, + [610] = {.lex_state = 13}, + [611] = {.lex_state = 13}, + [612] = {.lex_state = 13}, + [613] = {.lex_state = 13}, + [614] = {.lex_state = 7}, + [615] = {.lex_state = 7}, + [616] = {.lex_state = 11}, + [617] = {.lex_state = 11}, + [618] = {.lex_state = 13}, + [619] = {.lex_state = 13}, + [620] = {.lex_state = 13}, + [621] = {.lex_state = 13}, + [622] = {.lex_state = 7}, + [623] = {.lex_state = 7}, + [624] = {.lex_state = 7}, + [625] = {.lex_state = 7}, + [626] = {.lex_state = 13}, + [627] = {.lex_state = 7}, + [628] = {.lex_state = 7}, + [629] = {.lex_state = 7}, + [630] = {.lex_state = 7}, + [631] = {.lex_state = 7}, + [632] = {.lex_state = 7}, + [633] = {.lex_state = 13}, + [634] = {.lex_state = 7}, + [635] = {.lex_state = 7}, + [636] = {.lex_state = 11}, + [637] = {.lex_state = 11}, + [638] = {.lex_state = 11}, + [639] = {.lex_state = 11}, + [640] = {.lex_state = 12}, + [641] = {.lex_state = 12}, + [642] = {.lex_state = 13}, + [643] = {.lex_state = 11}, + [644] = {.lex_state = 7}, + [645] = {.lex_state = 11}, + [646] = {.lex_state = 11}, + [647] = {.lex_state = 11}, + [648] = {.lex_state = 13}, + [649] = {.lex_state = 11}, + [650] = {.lex_state = 11}, + [651] = {.lex_state = 11}, + [652] = {.lex_state = 11}, + [653] = {.lex_state = 11}, + [654] = {.lex_state = 11}, + [655] = {.lex_state = 11}, + [656] = {.lex_state = 7}, + [657] = {.lex_state = 11}, + [658] = {.lex_state = 11}, + [659] = {.lex_state = 11}, + [660] = {.lex_state = 12}, + [661] = {.lex_state = 12}, + [662] = {.lex_state = 12}, + [663] = {.lex_state = 12}, + [664] = {.lex_state = 12}, + [665] = {.lex_state = 11}, + [666] = {.lex_state = 11}, + [667] = {.lex_state = 12}, + [668] = {.lex_state = 12}, + [669] = {.lex_state = 12}, + [670] = {.lex_state = 12}, + [671] = {.lex_state = 12}, + [672] = {.lex_state = 12}, + [673] = {.lex_state = 12}, + [674] = {.lex_state = 12}, + [675] = {.lex_state = 12}, + [676] = {.lex_state = 12}, + [677] = {.lex_state = 11}, + [678] = {.lex_state = 12}, + [679] = {.lex_state = 12}, + [680] = {.lex_state = 12}, + [681] = {.lex_state = 12}, + [682] = {.lex_state = 12}, + [683] = {.lex_state = 12}, + [684] = {.lex_state = 15}, + [685] = {.lex_state = 12}, + [686] = {.lex_state = 12}, + [687] = {.lex_state = 12}, + [688] = {.lex_state = 12}, + [689] = {.lex_state = 15}, + [690] = {.lex_state = 7}, + [691] = {.lex_state = 12}, + [692] = {.lex_state = 12}, + [693] = {.lex_state = 12}, + [694] = {.lex_state = 12}, + [695] = {.lex_state = 11}, + [696] = {.lex_state = 12}, + [697] = {.lex_state = 12}, + [698] = {.lex_state = 12}, + [699] = {.lex_state = 12}, + [700] = {.lex_state = 12}, + [701] = {.lex_state = 12}, + [702] = {.lex_state = 12}, + [703] = {.lex_state = 11}, + [704] = {.lex_state = 12}, + [705] = {.lex_state = 11}, + [706] = {.lex_state = 11}, + [707] = {.lex_state = 7}, + [708] = {.lex_state = 11}, + [709] = {.lex_state = 11}, + [710] = {.lex_state = 11}, + [711] = {.lex_state = 11}, + [712] = {.lex_state = 11}, + [713] = {.lex_state = 11}, + [714] = {.lex_state = 11}, + [715] = {.lex_state = 11}, + [716] = {.lex_state = 15}, + [717] = {.lex_state = 15}, + [718] = {.lex_state = 15}, + [719] = {.lex_state = 15}, + [720] = {.lex_state = 15}, + [721] = {.lex_state = 11}, + [722] = {.lex_state = 15}, + [723] = {.lex_state = 15}, + [724] = {.lex_state = 15}, + [725] = {.lex_state = 15}, + [726] = {.lex_state = 15}, + [727] = {.lex_state = 15}, + [728] = {.lex_state = 15}, + [729] = {.lex_state = 15}, + [730] = {.lex_state = 15}, + [731] = {.lex_state = 15}, + [732] = {.lex_state = 11}, + [733] = {.lex_state = 15}, + [734] = {.lex_state = 15}, + [735] = {.lex_state = 15}, + [736] = {.lex_state = 15}, + [737] = {.lex_state = 15}, + [738] = {.lex_state = 15}, + [739] = {.lex_state = 9}, + [740] = {.lex_state = 9}, + [741] = {.lex_state = 11}, + [742] = {.lex_state = 15}, + [743] = {.lex_state = 15}, + [744] = {.lex_state = 15}, + [745] = {.lex_state = 15}, + [746] = {.lex_state = 5}, + [747] = {.lex_state = 11}, + [748] = {.lex_state = 15}, + [749] = {.lex_state = 15}, + [750] = {.lex_state = 15}, + [751] = {.lex_state = 15}, + [752] = {.lex_state = 5}, + [753] = {.lex_state = 5}, + [754] = {.lex_state = 5}, + [755] = {.lex_state = 5}, + [756] = {.lex_state = 15}, + [757] = {.lex_state = 15}, + [758] = {.lex_state = 15}, + [759] = {.lex_state = 15}, + [760] = {.lex_state = 9}, + [761] = {.lex_state = 9}, + [762] = {.lex_state = 9}, + [763] = {.lex_state = 9}, + [764] = {.lex_state = 9}, + [765] = {.lex_state = 5}, + [766] = {.lex_state = 15}, + [767] = {.lex_state = 9}, + [768] = {.lex_state = 9}, + [769] = {.lex_state = 9}, + [770] = {.lex_state = 9}, + [771] = {.lex_state = 9}, + [772] = {.lex_state = 9}, + [773] = {.lex_state = 9}, + [774] = {.lex_state = 9}, + [775] = {.lex_state = 9}, + [776] = {.lex_state = 9}, + [777] = {.lex_state = 15}, + [778] = {.lex_state = 9}, + [779] = {.lex_state = 9}, + [780] = {.lex_state = 9}, + [781] = {.lex_state = 9}, + [782] = {.lex_state = 9}, + [783] = {.lex_state = 9}, + [784] = {.lex_state = 5}, + [785] = {.lex_state = 15}, + [786] = {.lex_state = 9}, + [787] = {.lex_state = 9}, + [788] = {.lex_state = 9}, + [789] = {.lex_state = 9}, + [790] = {.lex_state = 5}, + [791] = {.lex_state = 5}, + [792] = {.lex_state = 15}, + [793] = {.lex_state = 9}, + [794] = {.lex_state = 9}, + [795] = {.lex_state = 9}, + [796] = {.lex_state = 9}, + [797] = {.lex_state = 5}, + [798] = {.lex_state = 5}, + [799] = {.lex_state = 5}, + [800] = {.lex_state = 9}, + [801] = {.lex_state = 9}, + [802] = {.lex_state = 9}, + [803] = {.lex_state = 9}, + [804] = {.lex_state = 5}, + [805] = {.lex_state = 5}, + [806] = {.lex_state = 5}, + [807] = {.lex_state = 9}, + [808] = {.lex_state = 5}, + [809] = {.lex_state = 5}, + [810] = {.lex_state = 5}, + [811] = {.lex_state = 5}, + [812] = {.lex_state = 5}, + [813] = {.lex_state = 5}, + [814] = {.lex_state = 9}, + [815] = {.lex_state = 5}, + [816] = {.lex_state = 5}, + [817] = {.lex_state = 5}, + [818] = {.lex_state = 5}, + [819] = {.lex_state = 5}, + [820] = {.lex_state = 5}, + [821] = {.lex_state = 14}, + [822] = {.lex_state = 14}, + [823] = {.lex_state = 3}, + [824] = {.lex_state = 3}, + [825] = {.lex_state = 3}, + [826] = {.lex_state = 3}, + [827] = {.lex_state = 3}, + [828] = {.lex_state = 3}, + [829] = {.lex_state = 3}, + [830] = {.lex_state = 3}, + [831] = {.lex_state = 3}, + [832] = {.lex_state = 3}, + [833] = {.lex_state = 3}, + [834] = {.lex_state = 3}, + [835] = {.lex_state = 3}, + [836] = {.lex_state = 3}, + [837] = {.lex_state = 3}, + [838] = {.lex_state = 3}, + [839] = {.lex_state = 3}, + [840] = {.lex_state = 3}, + [841] = {.lex_state = 3}, + [842] = {.lex_state = 3}, + [843] = {.lex_state = 3}, + [844] = {.lex_state = 3}, + [845] = {.lex_state = 3}, + [846] = {.lex_state = 3}, + [847] = {.lex_state = 3}, + [848] = {.lex_state = 3}, + [849] = {.lex_state = 3}, + [850] = {.lex_state = 3}, + [851] = {.lex_state = 3}, + [852] = {.lex_state = 3}, + [853] = {.lex_state = 3}, + [854] = {.lex_state = 3}, + [855] = {.lex_state = 3}, + [856] = {.lex_state = 3}, + [857] = {.lex_state = 3}, + [858] = {.lex_state = 3}, + [859] = {.lex_state = 3}, + [860] = {.lex_state = 3}, + [861] = {.lex_state = 3}, + [862] = {.lex_state = 3}, + [863] = {.lex_state = 3}, + [864] = {.lex_state = 3}, + [865] = {.lex_state = 3}, + [866] = {.lex_state = 3}, + [867] = {.lex_state = 3}, + [868] = {.lex_state = 3}, + [869] = {.lex_state = 3}, + [870] = {.lex_state = 3}, + [871] = {.lex_state = 3}, + [872] = {.lex_state = 3}, + [873] = {.lex_state = 3}, + [874] = {.lex_state = 3}, + [875] = {.lex_state = 3}, + [876] = {.lex_state = 3}, + [877] = {.lex_state = 3}, + [878] = {.lex_state = 3}, + [879] = {.lex_state = 3}, + [880] = {.lex_state = 3}, + [881] = {.lex_state = 3}, + [882] = {.lex_state = 3}, + [883] = {.lex_state = 3}, + [884] = {.lex_state = 3}, + [885] = {.lex_state = 3}, + [886] = {.lex_state = 3}, + [887] = {.lex_state = 3}, + [888] = {.lex_state = 3}, + [889] = {.lex_state = 3}, + [890] = {.lex_state = 3}, + [891] = {.lex_state = 3}, + [892] = {.lex_state = 3}, + [893] = {.lex_state = 3}, + [894] = {.lex_state = 3}, + [895] = {.lex_state = 3}, + [896] = {.lex_state = 3}, + [897] = {.lex_state = 3}, + [898] = {.lex_state = 3}, + [899] = {.lex_state = 3}, + [900] = {.lex_state = 3}, + [901] = {.lex_state = 3}, + [902] = {.lex_state = 3}, + [903] = {.lex_state = 3}, + [904] = {.lex_state = 3}, + [905] = {.lex_state = 3}, + [906] = {.lex_state = 3}, + [907] = {.lex_state = 3}, + [908] = {.lex_state = 3}, + [909] = {.lex_state = 3}, + [910] = {.lex_state = 3}, + [911] = {.lex_state = 3}, + [912] = {.lex_state = 3}, + [913] = {.lex_state = 3}, + [914] = {.lex_state = 3}, + [915] = {.lex_state = 3}, + [916] = {.lex_state = 3}, + [917] = {.lex_state = 3}, + [918] = {.lex_state = 3}, + [919] = {.lex_state = 3}, + [920] = {.lex_state = 3}, + [921] = {.lex_state = 3}, + [922] = {.lex_state = 3}, + [923] = {.lex_state = 3}, + [924] = {.lex_state = 3}, + [925] = {.lex_state = 3}, + [926] = {.lex_state = 3}, + [927] = {.lex_state = 3}, + [928] = {.lex_state = 3}, + [929] = {.lex_state = 3}, + [930] = {.lex_state = 3}, + [931] = {.lex_state = 3}, + [932] = {.lex_state = 3}, + [933] = {.lex_state = 3}, + [934] = {.lex_state = 3}, + [935] = {.lex_state = 3}, + [936] = {.lex_state = 3}, + [937] = {.lex_state = 3}, + [938] = {.lex_state = 3}, + [939] = {.lex_state = 3}, + [940] = {.lex_state = 3}, + [941] = {.lex_state = 3}, + [942] = {.lex_state = 3}, + [943] = {.lex_state = 3}, + [944] = {.lex_state = 3}, + [945] = {.lex_state = 22}, + [946] = {.lex_state = 0}, + [947] = {.lex_state = 0}, + [948] = {.lex_state = 0}, + [949] = {.lex_state = 0}, + [950] = {.lex_state = 0}, + [951] = {.lex_state = 0}, + [952] = {.lex_state = 0}, + [953] = {.lex_state = 0}, + [954] = {.lex_state = 0}, + [955] = {.lex_state = 0}, + [956] = {.lex_state = 0}, + [957] = {.lex_state = 0}, + [958] = {.lex_state = 0}, + [959] = {.lex_state = 0}, + [960] = {.lex_state = 0}, + [961] = {.lex_state = 0}, + [962] = {.lex_state = 0}, + [963] = {.lex_state = 0}, + [964] = {.lex_state = 0}, + [965] = {.lex_state = 0}, + [966] = {.lex_state = 0}, + [967] = {.lex_state = 0}, + [968] = {.lex_state = 0}, + [969] = {.lex_state = 0}, + [970] = {.lex_state = 0}, + [971] = {.lex_state = 0}, + [972] = {.lex_state = 0}, + [973] = {.lex_state = 0}, + [974] = {.lex_state = 0}, + [975] = {.lex_state = 0}, + [976] = {.lex_state = 0}, + [977] = {.lex_state = 0}, + [978] = {.lex_state = 0}, + [979] = {.lex_state = 0}, + [980] = {.lex_state = 0}, + [981] = {.lex_state = 0}, + [982] = {.lex_state = 0}, + [983] = {.lex_state = 0}, + [984] = {.lex_state = 0}, + [985] = {.lex_state = 0}, + [986] = {.lex_state = 0}, + [987] = {.lex_state = 0}, + [988] = {.lex_state = 0}, + [989] = {.lex_state = 0}, + [990] = {.lex_state = 0}, + [991] = {.lex_state = 0}, + [992] = {.lex_state = 0}, + [993] = {.lex_state = 0}, + [994] = {.lex_state = 0}, + [995] = {.lex_state = 0}, + [996] = {.lex_state = 0}, + [997] = {.lex_state = 0}, + [998] = {.lex_state = 0}, + [999] = {.lex_state = 0}, + [1000] = {.lex_state = 0}, + [1001] = {.lex_state = 0}, + [1002] = {.lex_state = 0}, + [1003] = {.lex_state = 0}, + [1004] = {.lex_state = 0}, + [1005] = {.lex_state = 0}, + [1006] = {.lex_state = 0}, + [1007] = {.lex_state = 0}, + [1008] = {.lex_state = 0}, + [1009] = {.lex_state = 0}, + [1010] = {.lex_state = 0}, + [1011] = {.lex_state = 0}, + [1012] = {.lex_state = 0}, + [1013] = {.lex_state = 0}, + [1014] = {.lex_state = 0}, + [1015] = {.lex_state = 0}, + [1016] = {.lex_state = 0}, + [1017] = {.lex_state = 0}, + [1018] = {.lex_state = 0}, + [1019] = {.lex_state = 0}, + [1020] = {.lex_state = 0}, + [1021] = {.lex_state = 0}, + [1022] = {.lex_state = 0}, + [1023] = {.lex_state = 0}, + [1024] = {.lex_state = 0}, + [1025] = {.lex_state = 0}, + [1026] = {.lex_state = 0}, + [1027] = {.lex_state = 0}, + [1028] = {.lex_state = 0}, + [1029] = {.lex_state = 0}, + [1030] = {.lex_state = 0}, + [1031] = {.lex_state = 0}, + [1032] = {.lex_state = 0}, + [1033] = {.lex_state = 0}, + [1034] = {.lex_state = 0}, + [1035] = {.lex_state = 0}, + [1036] = {.lex_state = 0}, + [1037] = {.lex_state = 0}, + [1038] = {.lex_state = 0}, + [1039] = {.lex_state = 0}, + [1040] = {.lex_state = 0}, + [1041] = {.lex_state = 0}, + [1042] = {.lex_state = 0}, + [1043] = {.lex_state = 0}, + [1044] = {.lex_state = 0}, + [1045] = {.lex_state = 0}, + [1046] = {.lex_state = 0}, + [1047] = {.lex_state = 0}, + [1048] = {.lex_state = 0}, + [1049] = {.lex_state = 0}, + [1050] = {.lex_state = 0}, + [1051] = {.lex_state = 0}, + [1052] = {.lex_state = 0}, + [1053] = {.lex_state = 0}, + [1054] = {.lex_state = 0}, + [1055] = {.lex_state = 0}, + [1056] = {.lex_state = 0}, + [1057] = {.lex_state = 0}, + [1058] = {.lex_state = 0}, + [1059] = {.lex_state = 0}, + [1060] = {.lex_state = 0}, + [1061] = {.lex_state = 0}, + [1062] = {.lex_state = 0}, + [1063] = {.lex_state = 0}, + [1064] = {.lex_state = 0}, + [1065] = {.lex_state = 0}, + [1066] = {.lex_state = 0}, + [1067] = {.lex_state = 0}, + [1068] = {.lex_state = 0}, + [1069] = {.lex_state = 0}, + [1070] = {.lex_state = 0}, + [1071] = {.lex_state = 0}, + [1072] = {.lex_state = 0}, + [1073] = {.lex_state = 0}, + [1074] = {.lex_state = 0}, + [1075] = {.lex_state = 0}, + [1076] = {.lex_state = 0}, + [1077] = {.lex_state = 0}, + [1078] = {.lex_state = 0}, + [1079] = {.lex_state = 0}, + [1080] = {.lex_state = 0}, + [1081] = {.lex_state = 0}, + [1082] = {.lex_state = 0}, + [1083] = {.lex_state = 0}, + [1084] = {.lex_state = 0}, + [1085] = {.lex_state = 0}, + [1086] = {.lex_state = 0}, + [1087] = {.lex_state = 0}, + [1088] = {.lex_state = 0}, + [1089] = {.lex_state = 0}, + [1090] = {.lex_state = 22}, + [1091] = {.lex_state = 22}, + [1092] = {.lex_state = 0}, + [1093] = {.lex_state = 0}, + [1094] = {.lex_state = 0}, + [1095] = {.lex_state = 0}, + [1096] = {.lex_state = 0}, + [1097] = {.lex_state = 0}, + [1098] = {.lex_state = 0}, + [1099] = {.lex_state = 0}, + [1100] = {.lex_state = 0}, + [1101] = {.lex_state = 0}, + [1102] = {.lex_state = 0}, + [1103] = {.lex_state = 0}, + [1104] = {.lex_state = 0}, + [1105] = {.lex_state = 0}, + [1106] = {.lex_state = 0}, + [1107] = {.lex_state = 0}, + [1108] = {.lex_state = 0}, + [1109] = {.lex_state = 0}, + [1110] = {.lex_state = 22}, + [1111] = {.lex_state = 0}, + [1112] = {.lex_state = 0}, + [1113] = {.lex_state = 0}, + [1114] = {.lex_state = 0}, + [1115] = {.lex_state = 0}, + [1116] = {.lex_state = 22}, + [1117] = {.lex_state = 0}, + [1118] = {.lex_state = 22}, + [1119] = {.lex_state = 0}, + [1120] = {.lex_state = 0}, + [1121] = {.lex_state = 0}, + [1122] = {.lex_state = 0}, + [1123] = {.lex_state = 18}, + [1124] = {.lex_state = 18}, + [1125] = {.lex_state = 18}, + [1126] = {.lex_state = 18}, + [1127] = {.lex_state = 18}, + [1128] = {.lex_state = 18}, + [1129] = {.lex_state = 18}, + [1130] = {.lex_state = 18}, + [1131] = {.lex_state = 18}, + [1132] = {.lex_state = 18}, + [1133] = {.lex_state = 18}, + [1134] = {.lex_state = 18}, + [1135] = {.lex_state = 18}, + [1136] = {.lex_state = 18}, + [1137] = {.lex_state = 0}, + [1138] = {.lex_state = 18}, + [1139] = {.lex_state = 0}, + [1140] = {.lex_state = 18}, + [1141] = {.lex_state = 0}, + [1142] = {.lex_state = 18}, + [1143] = {.lex_state = 18}, + [1144] = {.lex_state = 18}, + [1145] = {.lex_state = 18}, + [1146] = {.lex_state = 18}, + [1147] = {.lex_state = 18}, + [1148] = {.lex_state = 18}, + [1149] = {.lex_state = 18}, + [1150] = {.lex_state = 0}, + [1151] = {.lex_state = 0}, + [1152] = {.lex_state = 0}, + [1153] = {.lex_state = 0}, + [1154] = {.lex_state = 0}, + [1155] = {.lex_state = 0}, + [1156] = {.lex_state = 0}, + [1157] = {.lex_state = 0}, + [1158] = {.lex_state = 0}, + [1159] = {.lex_state = 0}, + [1160] = {.lex_state = 0}, + [1161] = {.lex_state = 0}, + [1162] = {.lex_state = 0}, + [1163] = {.lex_state = 0}, + [1164] = {.lex_state = 0}, + [1165] = {.lex_state = 0}, + [1166] = {.lex_state = 18}, + [1167] = {.lex_state = 4}, + [1168] = {.lex_state = 4}, + [1169] = {.lex_state = 4}, + [1170] = {.lex_state = 4}, + [1171] = {.lex_state = 4}, + [1172] = {.lex_state = 4}, + [1173] = {.lex_state = 4}, + [1174] = {.lex_state = 4}, + [1175] = {.lex_state = 4}, + [1176] = {.lex_state = 4}, + [1177] = {.lex_state = 4}, + [1178] = {.lex_state = 4}, + [1179] = {.lex_state = 23}, + [1180] = {.lex_state = 23}, + [1181] = {.lex_state = 23}, + [1182] = {.lex_state = 23}, + [1183] = {.lex_state = 17}, + [1184] = {.lex_state = 23}, + [1185] = {.lex_state = 23}, + [1186] = {.lex_state = 23}, + [1187] = {.lex_state = 23}, + [1188] = {.lex_state = 23}, + [1189] = {.lex_state = 23}, + [1190] = {.lex_state = 23}, + [1191] = {.lex_state = 23}, + [1192] = {.lex_state = 23}, + [1193] = {.lex_state = 23}, + [1194] = {.lex_state = 0}, + [1195] = {.lex_state = 0}, + [1196] = {.lex_state = 0}, + [1197] = {.lex_state = 0}, + [1198] = {.lex_state = 0}, + [1199] = {.lex_state = 0}, + [1200] = {.lex_state = 0}, + [1201] = {.lex_state = 0}, + [1202] = {.lex_state = 0}, + [1203] = {.lex_state = 0}, + [1204] = {.lex_state = 0}, + [1205] = {.lex_state = 0}, + [1206] = {.lex_state = 0}, + [1207] = {.lex_state = 0}, + [1208] = {.lex_state = 0}, + [1209] = {.lex_state = 0}, + [1210] = {.lex_state = 0}, + [1211] = {.lex_state = 0}, + [1212] = {.lex_state = 0}, + [1213] = {.lex_state = 0}, + [1214] = {.lex_state = 0}, + [1215] = {.lex_state = 0}, + [1216] = {.lex_state = 0}, + [1217] = {.lex_state = 0}, + [1218] = {.lex_state = 0}, + [1219] = {.lex_state = 24}, + [1220] = {.lex_state = 24}, + [1221] = {.lex_state = 24}, + [1222] = {.lex_state = 24}, + [1223] = {.lex_state = 24}, + [1224] = {.lex_state = 24}, + [1225] = {.lex_state = 24}, + [1226] = {.lex_state = 1}, + [1227] = {.lex_state = 2}, + [1228] = {.lex_state = 24}, + [1229] = {.lex_state = 24}, + [1230] = {.lex_state = 24}, + [1231] = {.lex_state = 24}, + [1232] = {.lex_state = 24}, + [1233] = {.lex_state = 24}, + [1234] = {.lex_state = 24}, + [1235] = {.lex_state = 24}, + [1236] = {.lex_state = 24}, + [1237] = {.lex_state = 1}, + [1238] = {.lex_state = 2}, + [1239] = {.lex_state = 4}, + [1240] = {.lex_state = 24}, + [1241] = {.lex_state = 24}, + [1242] = {.lex_state = 24}, + [1243] = {.lex_state = 0}, + [1244] = {.lex_state = 4}, + [1245] = {.lex_state = 24}, + [1246] = {.lex_state = 24}, + [1247] = {.lex_state = 24}, + [1248] = {.lex_state = 24}, + [1249] = {.lex_state = 24}, + [1250] = {.lex_state = 24}, + [1251] = {.lex_state = 24}, + [1252] = {.lex_state = 24}, + [1253] = {.lex_state = 24}, + [1254] = {.lex_state = 24}, + [1255] = {.lex_state = 1}, + [1256] = {.lex_state = 2}, + [1257] = {.lex_state = 24}, + [1258] = {.lex_state = 24}, + [1259] = {.lex_state = 24}, + [1260] = {.lex_state = 24}, + [1261] = {.lex_state = 24}, + [1262] = {.lex_state = 24}, + [1263] = {.lex_state = 24}, + [1264] = {.lex_state = 24}, + [1265] = {.lex_state = 1}, + [1266] = {.lex_state = 1}, + [1267] = {.lex_state = 2}, + [1268] = {.lex_state = 4}, + [1269] = {.lex_state = 24}, + [1270] = {.lex_state = 24}, + [1271] = {.lex_state = 24}, + [1272] = {.lex_state = 2}, + [1273] = {.lex_state = 24}, + [1274] = {.lex_state = 4}, + [1275] = {.lex_state = 24}, + [1276] = {.lex_state = 24}, + [1277] = {.lex_state = 24}, + [1278] = {.lex_state = 24}, + [1279] = {.lex_state = 24}, + [1280] = {.lex_state = 24}, + [1281] = {.lex_state = 24}, + [1282] = {.lex_state = 1}, + [1283] = {.lex_state = 2}, + [1284] = {.lex_state = 24}, + [1285] = {.lex_state = 4}, + [1286] = {.lex_state = 24}, + [1287] = {.lex_state = 24}, + [1288] = {.lex_state = 24}, + [1289] = {.lex_state = 24}, + [1290] = {.lex_state = 1}, + [1291] = {.lex_state = 2}, + [1292] = {.lex_state = 24}, + [1293] = {.lex_state = 24}, + [1294] = {.lex_state = 24}, + [1295] = {.lex_state = 24}, + [1296] = {.lex_state = 24}, + [1297] = {.lex_state = 24}, + [1298] = {.lex_state = 24}, + [1299] = {.lex_state = 24}, + [1300] = {.lex_state = 24}, + [1301] = {.lex_state = 1}, + [1302] = {.lex_state = 2}, + [1303] = {.lex_state = 4}, + [1304] = {.lex_state = 24}, + [1305] = {.lex_state = 24}, + [1306] = {.lex_state = 24}, + [1307] = {.lex_state = 24}, + [1308] = {.lex_state = 24}, + [1309] = {.lex_state = 24}, + [1310] = {.lex_state = 24}, + [1311] = {.lex_state = 24}, + [1312] = {.lex_state = 24}, + [1313] = {.lex_state = 24}, + [1314] = {.lex_state = 24}, + [1315] = {.lex_state = 1}, + [1316] = {.lex_state = 2}, + [1317] = {.lex_state = 24}, + [1318] = {.lex_state = 24}, + [1319] = {.lex_state = 24}, + [1320] = {.lex_state = 24}, + [1321] = {.lex_state = 24}, + [1322] = {.lex_state = 24}, + [1323] = {.lex_state = 24}, + [1324] = {.lex_state = 24}, + [1325] = {.lex_state = 24}, + [1326] = {.lex_state = 1}, + [1327] = {.lex_state = 2}, + [1328] = {.lex_state = 4}, + [1329] = {.lex_state = 24}, + [1330] = {.lex_state = 24}, + [1331] = {.lex_state = 24}, + [1332] = {.lex_state = 2}, + [1333] = {.lex_state = 24}, + [1334] = {.lex_state = 24}, + [1335] = {.lex_state = 4}, + [1336] = {.lex_state = 24}, + [1337] = {.lex_state = 24}, + [1338] = {.lex_state = 24}, + [1339] = {.lex_state = 24}, + [1340] = {.lex_state = 1}, + [1341] = {.lex_state = 2}, + [1342] = {.lex_state = 24}, + [1343] = {.lex_state = 24}, + [1344] = {.lex_state = 24}, + [1345] = {.lex_state = 24}, + [1346] = {.lex_state = 24}, + [1347] = {.lex_state = 24}, + [1348] = {.lex_state = 24}, + [1349] = {.lex_state = 24}, + [1350] = {.lex_state = 0}, + [1351] = {.lex_state = 1}, + [1352] = {.lex_state = 2}, + [1353] = {.lex_state = 4}, + [1354] = {.lex_state = 24}, + [1355] = {.lex_state = 24}, + [1356] = {.lex_state = 24}, + [1357] = {.lex_state = 24}, + [1358] = {.lex_state = 24}, + [1359] = {.lex_state = 24}, + [1360] = {.lex_state = 24}, + [1361] = {.lex_state = 24}, + [1362] = {.lex_state = 24}, + [1363] = {.lex_state = 24}, + [1364] = {.lex_state = 1}, + [1365] = {.lex_state = 2}, + [1366] = {.lex_state = 24}, + [1367] = {.lex_state = 24}, + [1368] = {.lex_state = 24}, + [1369] = {.lex_state = 24}, + [1370] = {.lex_state = 24}, + [1371] = {.lex_state = 24}, + [1372] = {.lex_state = 24}, + [1373] = {.lex_state = 24}, + [1374] = {.lex_state = 24}, + [1375] = {.lex_state = 1}, + [1376] = {.lex_state = 2}, + [1377] = {.lex_state = 24}, + [1378] = {.lex_state = 24}, + [1379] = {.lex_state = 24}, + [1380] = {.lex_state = 24}, + [1381] = {.lex_state = 24}, + [1382] = {.lex_state = 24}, + [1383] = {.lex_state = 24}, + [1384] = {.lex_state = 24}, + [1385] = {.lex_state = 1}, + [1386] = {.lex_state = 2}, + [1387] = {.lex_state = 4}, + [1388] = {.lex_state = 24}, + [1389] = {.lex_state = 24}, + [1390] = {.lex_state = 24}, + [1391] = {.lex_state = 24}, + [1392] = {.lex_state = 1}, + [1393] = {.lex_state = 2}, + [1394] = {.lex_state = 24}, + [1395] = {.lex_state = 1}, + [1396] = {.lex_state = 2}, + [1397] = {.lex_state = 24}, + [1398] = {.lex_state = 351}, + [1399] = {.lex_state = 351}, + [1400] = {.lex_state = 24}, + [1401] = {.lex_state = 24}, + [1402] = {.lex_state = 24}, + [1403] = {.lex_state = 24}, + [1404] = {.lex_state = 0}, + [1405] = {.lex_state = 24}, + [1406] = {.lex_state = 24}, + [1407] = {.lex_state = 24}, + [1408] = {.lex_state = 2}, + [1409] = {.lex_state = 351}, + [1410] = {.lex_state = 24}, + [1411] = {.lex_state = 1}, + [1412] = {.lex_state = 2}, + [1413] = {.lex_state = 4}, + [1414] = {.lex_state = 24}, + [1415] = {.lex_state = 24}, + [1416] = {.lex_state = 24}, + [1417] = {.lex_state = 351}, + [1418] = {.lex_state = 351}, + [1419] = {.lex_state = 24}, + [1420] = {.lex_state = 24}, + [1421] = {.lex_state = 24}, + [1422] = {.lex_state = 24}, + [1423] = {.lex_state = 24}, + [1424] = {.lex_state = 24}, + [1425] = {.lex_state = 351}, + [1426] = {.lex_state = 351}, + [1427] = {.lex_state = 24}, + [1428] = {.lex_state = 1}, + [1429] = {.lex_state = 2}, + [1430] = {.lex_state = 0}, + [1431] = {.lex_state = 24}, + [1432] = {.lex_state = 24}, + [1433] = {.lex_state = 24}, + [1434] = {.lex_state = 351}, + [1435] = {.lex_state = 351}, + [1436] = {.lex_state = 24}, + [1437] = {.lex_state = 24}, + [1438] = {.lex_state = 351}, + [1439] = {.lex_state = 351}, + [1440] = {.lex_state = 4}, + [1441] = {.lex_state = 24}, + [1442] = {.lex_state = 24}, + [1443] = {.lex_state = 24}, + [1444] = {.lex_state = 24}, + [1445] = {.lex_state = 24}, + [1446] = {.lex_state = 24}, + [1447] = {.lex_state = 351}, + [1448] = {.lex_state = 351}, + [1449] = {.lex_state = 24}, + [1450] = {.lex_state = 24}, + [1451] = {.lex_state = 1}, + [1452] = {.lex_state = 24}, + [1453] = {.lex_state = 2}, + [1454] = {.lex_state = 24}, + [1455] = {.lex_state = 24}, + [1456] = {.lex_state = 351}, + [1457] = {.lex_state = 351}, + [1458] = {.lex_state = 24}, + [1459] = {.lex_state = 24}, + [1460] = {.lex_state = 24}, + [1461] = {.lex_state = 24}, + [1462] = {.lex_state = 24}, + [1463] = {.lex_state = 351}, + [1464] = {.lex_state = 351}, + [1465] = {.lex_state = 24}, + [1466] = {.lex_state = 24}, + [1467] = {.lex_state = 1}, + [1468] = {.lex_state = 2}, + [1469] = {.lex_state = 4}, + [1470] = {.lex_state = 24}, + [1471] = {.lex_state = 24}, + [1472] = {.lex_state = 24}, + [1473] = {.lex_state = 351}, + [1474] = {.lex_state = 351}, + [1475] = {.lex_state = 24}, + [1476] = {.lex_state = 24}, + [1477] = {.lex_state = 24}, + [1478] = {.lex_state = 1}, + [1479] = {.lex_state = 24}, + [1480] = {.lex_state = 1}, + [1481] = {.lex_state = 351}, + [1482] = {.lex_state = 351}, + [1483] = {.lex_state = 2}, + [1484] = {.lex_state = 4}, + [1485] = {.lex_state = 24}, + [1486] = {.lex_state = 24}, + [1487] = {.lex_state = 24}, + [1488] = {.lex_state = 2}, + [1489] = {.lex_state = 351}, + [1490] = {.lex_state = 0}, + [1491] = {.lex_state = 0}, + [1492] = {.lex_state = 1}, + [1493] = {.lex_state = 1}, + [1494] = {.lex_state = 24}, + [1495] = {.lex_state = 24}, + [1496] = {.lex_state = 0}, + [1497] = {.lex_state = 24}, + [1498] = {.lex_state = 24}, + [1499] = {.lex_state = 2}, + [1500] = {.lex_state = 24}, + [1501] = {.lex_state = 1}, + [1502] = {.lex_state = 2}, + [1503] = {.lex_state = 24}, + [1504] = {.lex_state = 24}, + [1505] = {.lex_state = 24}, + [1506] = {.lex_state = 24}, + [1507] = {.lex_state = 24}, + [1508] = {.lex_state = 24}, + [1509] = {.lex_state = 24}, + [1510] = {.lex_state = 24}, + [1511] = {.lex_state = 1}, + [1512] = {.lex_state = 2}, + [1513] = {.lex_state = 4}, + [1514] = {.lex_state = 24}, + [1515] = {.lex_state = 0}, + [1516] = {.lex_state = 24}, + [1517] = {.lex_state = 24}, + [1518] = {.lex_state = 4}, + [1519] = {.lex_state = 4}, + [1520] = {.lex_state = 24}, + [1521] = {.lex_state = 24}, + [1522] = {.lex_state = 24}, + [1523] = {.lex_state = 24}, + [1524] = {.lex_state = 24}, + [1525] = {.lex_state = 1}, + [1526] = {.lex_state = 2}, + [1527] = {.lex_state = 24}, + [1528] = {.lex_state = 24}, + [1529] = {.lex_state = 24}, + [1530] = {.lex_state = 24}, + [1531] = {.lex_state = 24}, + [1532] = {.lex_state = 24}, + [1533] = {.lex_state = 24}, + [1534] = {.lex_state = 24}, + [1535] = {.lex_state = 24}, + [1536] = {.lex_state = 351}, + [1537] = {.lex_state = 1}, + [1538] = {.lex_state = 351}, + [1539] = {.lex_state = 351}, + [1540] = {.lex_state = 4}, + [1541] = {.lex_state = 351}, + [1542] = {.lex_state = 351}, + [1543] = {.lex_state = 351}, + [1544] = {.lex_state = 351}, + [1545] = {.lex_state = 351}, + [1546] = {.lex_state = 351}, + [1547] = {.lex_state = 4}, + [1548] = {.lex_state = 351}, + [1549] = {.lex_state = 0}, + [1550] = {.lex_state = 351}, + [1551] = {.lex_state = 351}, + [1552] = {.lex_state = 351}, + [1553] = {.lex_state = 351}, + [1554] = {.lex_state = 351}, + [1555] = {.lex_state = 4}, + [1556] = {.lex_state = 351}, + [1557] = {.lex_state = 351}, + [1558] = {.lex_state = 0}, + [1559] = {.lex_state = 0}, + [1560] = {.lex_state = 351}, + [1561] = {.lex_state = 16}, + [1562] = {.lex_state = 0}, + [1563] = {.lex_state = 351}, + [1564] = {.lex_state = 4}, + [1565] = {.lex_state = 4}, + [1566] = {.lex_state = 351}, + [1567] = {.lex_state = 24}, + [1568] = {.lex_state = 24}, + [1569] = {.lex_state = 0}, + [1570] = {.lex_state = 16}, + [1571] = {.lex_state = 0}, + [1572] = {.lex_state = 0}, + [1573] = {.lex_state = 24}, + [1574] = {.lex_state = 0}, + [1575] = {.lex_state = 351}, + [1576] = {.lex_state = 351}, + [1577] = {.lex_state = 351}, + [1578] = {.lex_state = 4}, + [1579] = {.lex_state = 4}, + [1580] = {.lex_state = 0}, + [1581] = {.lex_state = 351}, + [1582] = {.lex_state = 4}, + [1583] = {.lex_state = 0}, + [1584] = {.lex_state = 351}, + [1585] = {.lex_state = 4}, + [1586] = {.lex_state = 0}, + [1587] = {.lex_state = 0}, + [1588] = {.lex_state = 0}, + [1589] = {.lex_state = 0}, + [1590] = {.lex_state = 0}, + [1591] = {.lex_state = 0}, + [1592] = {.lex_state = 0}, + [1593] = {.lex_state = 24}, + [1594] = {.lex_state = 4}, + [1595] = {.lex_state = 0}, + [1596] = {.lex_state = 0}, + [1597] = {.lex_state = 4}, + [1598] = {.lex_state = 0}, + [1599] = {.lex_state = 351}, + [1600] = {.lex_state = 4}, + [1601] = {.lex_state = 0}, + [1602] = {.lex_state = 0}, + [1603] = {.lex_state = 16}, + [1604] = {.lex_state = 0}, + [1605] = {.lex_state = 0}, + [1606] = {.lex_state = 0}, + [1607] = {.lex_state = 0}, + [1608] = {.lex_state = 4}, + [1609] = {.lex_state = 4}, + [1610] = {.lex_state = 16}, + [1611] = {.lex_state = 0}, + [1612] = {.lex_state = 0}, + [1613] = {.lex_state = 0}, + [1614] = {.lex_state = 0}, + [1615] = {.lex_state = 0}, + [1616] = {.lex_state = 16}, + [1617] = {.lex_state = 0}, + [1618] = {.lex_state = 0}, + [1619] = {.lex_state = 0}, + [1620] = {.lex_state = 0}, + [1621] = {.lex_state = 4}, + [1622] = {.lex_state = 0}, + [1623] = {.lex_state = 0}, + [1624] = {.lex_state = 4}, + [1625] = {.lex_state = 0}, + [1626] = {.lex_state = 0}, + [1627] = {.lex_state = 0}, + [1628] = {.lex_state = 0}, + [1629] = {.lex_state = 0}, + [1630] = {.lex_state = 0}, + [1631] = {.lex_state = 0}, + [1632] = {.lex_state = 0}, + [1633] = {.lex_state = 0}, + [1634] = {.lex_state = 0}, + [1635] = {.lex_state = 0}, + [1636] = {.lex_state = 16}, + [1637] = {.lex_state = 0}, + [1638] = {.lex_state = 4}, + [1639] = {.lex_state = 0}, + [1640] = {.lex_state = 0}, + [1641] = {.lex_state = 0}, + [1642] = {.lex_state = 0}, + [1643] = {.lex_state = 351}, + [1644] = {.lex_state = 0}, + [1645] = {.lex_state = 0}, + [1646] = {.lex_state = 0}, + [1647] = {.lex_state = 0}, + [1648] = {.lex_state = 16}, + [1649] = {.lex_state = 16}, + [1650] = {.lex_state = 0}, + [1651] = {.lex_state = 16}, + [1652] = {.lex_state = 0}, + [1653] = {.lex_state = 0}, + [1654] = {.lex_state = 16}, + [1655] = {.lex_state = 0}, + [1656] = {.lex_state = 0}, + [1657] = {.lex_state = 0}, + [1658] = {.lex_state = 4}, + [1659] = {.lex_state = 16}, + [1660] = {.lex_state = 0}, + [1661] = {.lex_state = 4}, + [1662] = {.lex_state = 0}, + [1663] = {.lex_state = 0}, + [1664] = {.lex_state = 0}, + [1665] = {.lex_state = 16}, + [1666] = {.lex_state = 4}, + [1667] = {.lex_state = 0}, + [1668] = {.lex_state = 0}, + [1669] = {.lex_state = 4}, + [1670] = {.lex_state = 16}, + [1671] = {.lex_state = 0}, + [1672] = {.lex_state = 0}, + [1673] = {.lex_state = 0}, + [1674] = {.lex_state = 0}, + [1675] = {.lex_state = 0}, + [1676] = {.lex_state = 16}, + [1677] = {.lex_state = 0}, + [1678] = {.lex_state = 0}, + [1679] = {.lex_state = 0}, + [1680] = {.lex_state = 0}, + [1681] = {.lex_state = 0}, + [1682] = {.lex_state = 0}, + [1683] = {.lex_state = 351}, + [1684] = {.lex_state = 0}, + [1685] = {.lex_state = 16}, + [1686] = {.lex_state = 0}, + [1687] = {.lex_state = 0}, + [1688] = {.lex_state = 0}, + [1689] = {.lex_state = 0}, + [1690] = {.lex_state = 0}, + [1691] = {.lex_state = 4}, + [1692] = {.lex_state = 16}, + [1693] = {.lex_state = 16}, + [1694] = {.lex_state = 0}, + [1695] = {.lex_state = 0}, + [1696] = {.lex_state = 0}, + [1697] = {.lex_state = 0}, + [1698] = {.lex_state = 0}, + [1699] = {.lex_state = 16}, + [1700] = {.lex_state = 0}, + [1701] = {.lex_state = 0}, + [1702] = {.lex_state = 0}, + [1703] = {.lex_state = 0}, + [1704] = {.lex_state = 0}, + [1705] = {.lex_state = 0}, + [1706] = {.lex_state = 16}, + [1707] = {.lex_state = 0}, + [1708] = {.lex_state = 16}, + [1709] = {.lex_state = 4}, + [1710] = {.lex_state = 0}, + [1711] = {.lex_state = 0}, + [1712] = {.lex_state = 0}, + [1713] = {.lex_state = 16}, + [1714] = {.lex_state = 0}, + [1715] = {.lex_state = 16}, + [1716] = {.lex_state = 0}, + [1717] = {.lex_state = 0}, + [1718] = {.lex_state = 0}, + [1719] = {.lex_state = 0}, + [1720] = {.lex_state = 0}, + [1721] = {.lex_state = 0}, + [1722] = {.lex_state = 0}, + [1723] = {.lex_state = 0}, + [1724] = {.lex_state = 0}, + [1725] = {.lex_state = 0}, + [1726] = {.lex_state = 0}, + [1727] = {.lex_state = 0}, + [1728] = {.lex_state = 0}, + [1729] = {.lex_state = 0}, + [1730] = {.lex_state = 0}, + [1731] = {.lex_state = 0}, + [1732] = {.lex_state = 4}, + [1733] = {.lex_state = 0}, + [1734] = {.lex_state = 0}, + [1735] = {.lex_state = 0}, + [1736] = {.lex_state = 0}, + [1737] = {.lex_state = 0}, + [1738] = {.lex_state = 351}, + [1739] = {.lex_state = 0}, + [1740] = {.lex_state = 351}, + [1741] = {.lex_state = 351}, + [1742] = {.lex_state = 351}, + [1743] = {.lex_state = 351}, + [1744] = {.lex_state = 351}, + [1745] = {.lex_state = 351}, + [1746] = {.lex_state = 351}, + [1747] = {.lex_state = 351}, + [1748] = {.lex_state = 351}, + [1749] = {.lex_state = 351}, + [1750] = {.lex_state = 4}, + [1751] = {.lex_state = 4}, + [1752] = {.lex_state = 4}, + [1753] = {.lex_state = 4}, + [1754] = {.lex_state = 4}, + [1755] = {.lex_state = 4}, + [1756] = {.lex_state = 4}, + [1757] = {.lex_state = 4}, + [1758] = {.lex_state = 4}, + [1759] = {.lex_state = 4}, + [1760] = {.lex_state = 4}, + [1761] = {.lex_state = 0}, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [STATE(0)] = { + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_TITLE] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [anon_sym_VERSION] = ACTIONS(1), + [anon_sym_COLON] = ACTIONS(1), + [anon_sym_BEGIN] = ACTIONS(1), + [anon_sym_END_ORGANIZATION_BLOCK] = ACTIONS(1), + [anon_sym_FUNCTION_BLOCK] = ACTIONS(1), + [anon_sym_FUNCTION] = ACTIONS(1), + [anon_sym_END_FUNCTION] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_COLON_EQ] = ACTIONS(1), + [anon_sym_TRUE] = ACTIONS(1), + [anon_sym_FALSE] = ACTIONS(1), + [anon_sym_VAR_INPUT] = ACTIONS(1), + [anon_sym_VAR_OUTPUT] = ACTIONS(1), + [anon_sym_VAR_IN_OUT] = ACTIONS(1), + [anon_sym_VAR] = ACTIONS(1), + [anon_sym_VAR_TEMP] = ACTIONS(1), + [anon_sym_CONSTANT] = ACTIONS(1), + [anon_sym_RETAIN] = ACTIONS(1), + [anon_sym_NON_RETAIN] = ACTIONS(1), + [anon_sym_VAR_CONSTANT] = ACTIONS(1), + [anon_sym_VAR_RETAIN] = ACTIONS(1), + [anon_sym_VAR_NON_RETAIN] = ACTIONS(1), + [anon_sym_END_VAR] = ACTIONS(1), + [anon_sym_BOOL] = ACTIONS(1), + [anon_sym_Bool] = ACTIONS(1), + [anon_sym_INT] = ACTIONS(1), + [anon_sym_Int] = ACTIONS(1), + [anon_sym_int] = ACTIONS(1), + [anon_sym_DINT] = ACTIONS(1), + [anon_sym_DInt] = ACTIONS(1), + [anon_sym_dint] = ACTIONS(1), + [anon_sym_SINT] = ACTIONS(1), + [anon_sym_SInt] = ACTIONS(1), + [anon_sym_sint] = ACTIONS(1), + [anon_sym_USINT] = ACTIONS(1), + [anon_sym_USInt] = ACTIONS(1), + [anon_sym_usint] = ACTIONS(1), + [anon_sym_UINT] = ACTIONS(1), + [anon_sym_UInt] = ACTIONS(1), + [anon_sym_uint] = ACTIONS(1), + [anon_sym_WORD] = ACTIONS(1), + [anon_sym_Word] = ACTIONS(1), + [anon_sym_word] = ACTIONS(1), + [anon_sym_DWORD] = ACTIONS(1), + [anon_sym_DWord] = ACTIONS(1), + [anon_sym_dword] = ACTIONS(1), + [anon_sym_Byte] = ACTIONS(1), + [anon_sym_byte] = ACTIONS(1), + [anon_sym_REAL] = ACTIONS(1), + [anon_sym_Real] = ACTIONS(1), + [anon_sym_real] = ACTIONS(1), + [anon_sym_LREAL] = ACTIONS(1), + [anon_sym_LReal] = ACTIONS(1), + [anon_sym_lreal] = ACTIONS(1), + [anon_sym_TIME] = ACTIONS(1), + [anon_sym_Time] = ACTIONS(1), + [anon_sym_time] = ACTIONS(1), + [anon_sym_Tod] = ACTIONS(1), + [anon_sym_tod] = ACTIONS(1), + [anon_sym_DT] = ACTIONS(1), + [anon_sym_Dt] = ACTIONS(1), + [anon_sym_dt] = ACTIONS(1), + [anon_sym_String] = ACTIONS(1), + [anon_sym_STRING] = ACTIONS(1), + [anon_sym_string] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [anon_sym_WString] = ACTIONS(1), + [anon_sym_WSTRING] = ACTIONS(1), + [anon_sym_wstring] = ACTIONS(1), + [anon_sym_Char] = ACTIONS(1), + [anon_sym_CHAR] = ACTIONS(1), + [anon_sym_char] = ACTIONS(1), + [anon_sym_WChar] = ACTIONS(1), + [anon_sym_WCHAR] = ACTIONS(1), + [anon_sym_wchar] = ACTIONS(1), + [anon_sym_ARRAY] = ACTIONS(1), + [anon_sym_DOT_DOT] = ACTIONS(1), + [anon_sym_OF] = ACTIONS(1), + [anon_sym_POUND] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), + [anon_sym_IF] = ACTIONS(1), + [anon_sym_THEN] = ACTIONS(1), + [anon_sym_END_IF] = ACTIONS(1), + [anon_sym_ELSIF] = ACTIONS(1), + [anon_sym_ELSE] = ACTIONS(1), + [anon_sym_CASE] = ACTIONS(1), + [anon_sym_END_CASE] = ACTIONS(1), + [anon_sym_FOR] = ACTIONS(1), + [anon_sym_TO] = ACTIONS(1), + [anon_sym_BY] = ACTIONS(1), + [anon_sym_DO] = ACTIONS(1), + [anon_sym_END_FOR] = ACTIONS(1), + [anon_sym_WHILE] = ACTIONS(1), + [anon_sym_END_WHILE] = ACTIONS(1), + [anon_sym_REPEAT] = ACTIONS(1), + [anon_sym_UNTIL] = ACTIONS(1), + [anon_sym_END_REPEAT] = ACTIONS(1), + [anon_sym_REGION] = ACTIONS(1), + [anon_sym_END_REGION] = ACTIONS(1), + [anon_sym_SLASH] = ACTIONS(1), + [anon_sym_DASH] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_EQ_GT] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_NOT] = ACTIONS(1), + [anon_sym_PLUS] = ACTIONS(1), + [anon_sym_OR] = ACTIONS(1), + [anon_sym_XOR] = ACTIONS(1), + [anon_sym_AND] = ACTIONS(1), + [anon_sym_LT_GT] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [anon_sym_LT_EQ] = ACTIONS(1), + [anon_sym_GT_EQ] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_MOD] = ACTIONS(1), + [sym_number] = ACTIONS(1), + [sym_hex_number] = ACTIONS(1), + [sym_time_value] = ACTIONS(1), + [anon_sym_SQUOTE] = ACTIONS(1), + [anon_sym_SQUOTE_SQUOTE] = ACTIONS(1), + [anon_sym_DQUOTE] = ACTIONS(1), + [anon_sym_DQUOTE_DQUOTE] = ACTIONS(1), + [sym_line_comment] = ACTIONS(3), + [sym_block_comment] = ACTIONS(3), + [sym_c_style_comment] = ACTIONS(3), + [sym_exit_statement] = ACTIONS(1), + [sym_continue_statement] = ACTIONS(1), + }, + [STATE(1)] = { + [sym_source_file] = STATE(1675), + [sym_organization_block] = STATE(7), + [sym_function_block] = STATE(7), + [sym_function] = STATE(7), + [sym_var_declaration] = STATE(356), + [sym_var_temp_declaration] = STATE(356), + [sym_var_constant_declaration] = STATE(356), + [sym_var_retain_declaration] = STATE(356), + [sym_var_non_retain_declaration] = STATE(356), + [sym_statement] = STATE(7), + [sym_empty_statement] = STATE(356), + [sym_assignment] = STATE(356), + [sym_lvalue] = STATE(1544), + [sym_function_name] = STATE(1554), + [sym_prefixed_identifier] = STATE(1554), + [sym_field_access] = STATE(1554), + [sym_array_access] = STATE(1554), + [sym_if_statement] = STATE(356), + [sym_case_statement] = STATE(356), + [sym_for_statement] = STATE(356), + [sym_while_statement] = STATE(356), + [sym_repeat_statement] = STATE(356), + [sym_region_statement] = STATE(356), + [sym_function_call] = STATE(356), + [sym_string] = STATE(1536), + [aux_sym_source_file_repeat1] = STATE(7), + [ts_builtin_sym_end] = ACTIONS(5), + [anon_sym_ORGANIZATION_BLOCK] = ACTIONS(7), + [anon_sym_FUNCTION_BLOCK] = ACTIONS(9), + [anon_sym_FUNCTION] = ACTIONS(11), + [anon_sym_SEMI] = ACTIONS(13), + [anon_sym_VAR_INPUT] = ACTIONS(15), + [anon_sym_VAR_OUTPUT] = ACTIONS(15), + [anon_sym_VAR_IN_OUT] = ACTIONS(15), + [anon_sym_VAR] = ACTIONS(17), + [anon_sym_VAR_TEMP] = ACTIONS(19), + [anon_sym_VAR_CONSTANT] = ACTIONS(21), + [anon_sym_VAR_RETAIN] = ACTIONS(23), + [anon_sym_VAR_NON_RETAIN] = ACTIONS(25), + [anon_sym_POUND] = ACTIONS(27), + [anon_sym_IF] = ACTIONS(29), + [anon_sym_CASE] = ACTIONS(31), + [anon_sym_FOR] = ACTIONS(33), + [anon_sym_WHILE] = ACTIONS(35), + [anon_sym_REPEAT] = ACTIONS(37), + [anon_sym_REGION] = ACTIONS(39), + [anon_sym_SQUOTE] = ACTIONS(41), + [anon_sym_DQUOTE] = ACTIONS(43), + [sym_identifier] = ACTIONS(45), + [sym_line_comment] = ACTIONS(3), + [sym_block_comment] = ACTIONS(3), + [sym_c_style_comment] = ACTIONS(3), + [sym_exit_statement] = ACTIONS(47), + [sym_continue_statement] = ACTIONS(47), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 8, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(53), 1, + anon_sym_ARRAY, + STATE(1575), 1, + sym_type, + STATE(1576), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(51), 6, + anon_sym_String, + anon_sym_STRING, + anon_sym_string, + anon_sym_WString, + anon_sym_WSTRING, + anon_sym_wstring, + ACTIONS(49), 48, + anon_sym_BOOL, + anon_sym_Bool, + anon_sym_INT, + anon_sym_Int, + anon_sym_int, + anon_sym_DINT, + anon_sym_DInt, + anon_sym_dint, + anon_sym_SINT, + anon_sym_SInt, + anon_sym_sint, + anon_sym_USINT, + anon_sym_USInt, + anon_sym_usint, + anon_sym_UINT, + anon_sym_UInt, + anon_sym_uint, + anon_sym_WORD, + anon_sym_Word, + anon_sym_word, + anon_sym_DWORD, + anon_sym_DWord, + anon_sym_dword, + anon_sym_BYTE, + anon_sym_Byte, + anon_sym_byte, + anon_sym_REAL, + anon_sym_Real, + anon_sym_real, + anon_sym_LREAL, + anon_sym_LReal, + anon_sym_lreal, + anon_sym_TIME, + anon_sym_Time, + anon_sym_time, + anon_sym_TOD, + anon_sym_Tod, + anon_sym_tod, + anon_sym_DT, + anon_sym_Dt, + anon_sym_dt, + anon_sym_Char, + anon_sym_CHAR, + anon_sym_char, + anon_sym_WChar, + anon_sym_WCHAR, + anon_sym_wchar, + sym_identifier, + [79] = 8, + ACTIONS(59), 1, + anon_sym_ARRAY, + ACTIONS(61), 1, + anon_sym_SQUOTE, + ACTIONS(63), 1, + anon_sym_DQUOTE, + STATE(1092), 1, + sym_type, + STATE(1095), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(57), 6, + anon_sym_String, + anon_sym_STRING, + anon_sym_string, + anon_sym_WString, + anon_sym_WSTRING, + anon_sym_wstring, + ACTIONS(55), 48, + anon_sym_BOOL, + anon_sym_Bool, + anon_sym_INT, + anon_sym_Int, + anon_sym_int, + anon_sym_DINT, + anon_sym_DInt, + anon_sym_dint, + anon_sym_SINT, + anon_sym_SInt, + anon_sym_sint, + anon_sym_USINT, + anon_sym_USInt, + anon_sym_usint, + anon_sym_UINT, + anon_sym_UInt, + anon_sym_uint, + anon_sym_WORD, + anon_sym_Word, + anon_sym_word, + anon_sym_DWORD, + anon_sym_DWord, + anon_sym_dword, + anon_sym_BYTE, + anon_sym_Byte, + anon_sym_byte, + anon_sym_REAL, + anon_sym_Real, + anon_sym_real, + anon_sym_LREAL, + anon_sym_LReal, + anon_sym_lreal, + anon_sym_TIME, + anon_sym_Time, + anon_sym_time, + anon_sym_TOD, + anon_sym_Tod, + anon_sym_tod, + anon_sym_DT, + anon_sym_Dt, + anon_sym_dt, + anon_sym_Char, + anon_sym_CHAR, + anon_sym_char, + anon_sym_WChar, + anon_sym_WCHAR, + anon_sym_wchar, + sym_identifier, + [158] = 8, + ACTIONS(59), 1, + anon_sym_ARRAY, + ACTIONS(61), 1, + anon_sym_SQUOTE, + ACTIONS(63), 1, + anon_sym_DQUOTE, + STATE(946), 1, + sym_type, + STATE(1095), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(57), 6, + anon_sym_String, + anon_sym_STRING, + anon_sym_string, + anon_sym_WString, + anon_sym_WSTRING, + anon_sym_wstring, + ACTIONS(55), 48, + anon_sym_BOOL, + anon_sym_Bool, + anon_sym_INT, + anon_sym_Int, + anon_sym_int, + anon_sym_DINT, + anon_sym_DInt, + anon_sym_dint, + anon_sym_SINT, + anon_sym_SInt, + anon_sym_sint, + anon_sym_USINT, + anon_sym_USInt, + anon_sym_usint, + anon_sym_UINT, + anon_sym_UInt, + anon_sym_uint, + anon_sym_WORD, + anon_sym_Word, + anon_sym_word, + anon_sym_DWORD, + anon_sym_DWord, + anon_sym_dword, + anon_sym_BYTE, + anon_sym_Byte, + anon_sym_byte, + anon_sym_REAL, + anon_sym_Real, + anon_sym_real, + anon_sym_LREAL, + anon_sym_LReal, + anon_sym_lreal, + anon_sym_TIME, + anon_sym_Time, + anon_sym_time, + anon_sym_TOD, + anon_sym_Tod, + anon_sym_tod, + anon_sym_DT, + anon_sym_Dt, + anon_sym_dt, + anon_sym_Char, + anon_sym_CHAR, + anon_sym_char, + anon_sym_WChar, + anon_sym_WCHAR, + anon_sym_wchar, + sym_identifier, + [237] = 8, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(53), 1, + anon_sym_ARRAY, + STATE(1566), 1, + sym_type, + STATE(1576), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(51), 6, + anon_sym_String, + anon_sym_STRING, + anon_sym_string, + anon_sym_WString, + anon_sym_WSTRING, + anon_sym_wstring, + ACTIONS(49), 48, + anon_sym_BOOL, + anon_sym_Bool, + anon_sym_INT, + anon_sym_Int, + anon_sym_int, + anon_sym_DINT, + anon_sym_DInt, + anon_sym_dint, + anon_sym_SINT, + anon_sym_SInt, + anon_sym_sint, + anon_sym_USINT, + anon_sym_USInt, + anon_sym_usint, + anon_sym_UINT, + anon_sym_UInt, + anon_sym_uint, + anon_sym_WORD, + anon_sym_Word, + anon_sym_word, + anon_sym_DWORD, + anon_sym_DWord, + anon_sym_dword, + anon_sym_BYTE, + anon_sym_Byte, + anon_sym_byte, + anon_sym_REAL, + anon_sym_Real, + anon_sym_real, + anon_sym_LREAL, + anon_sym_LReal, + anon_sym_lreal, + anon_sym_TIME, + anon_sym_Time, + anon_sym_time, + anon_sym_TOD, + anon_sym_Tod, + anon_sym_tod, + anon_sym_DT, + anon_sym_Dt, + anon_sym_dt, + anon_sym_Char, + anon_sym_CHAR, + anon_sym_char, + anon_sym_WChar, + anon_sym_WCHAR, + anon_sym_wchar, + sym_identifier, + [316] = 8, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(53), 1, + anon_sym_ARRAY, + STATE(1576), 1, + sym_string, + STATE(1584), 1, + sym_type, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(51), 6, + anon_sym_String, + anon_sym_STRING, + anon_sym_string, + anon_sym_WString, + anon_sym_WSTRING, + anon_sym_wstring, + ACTIONS(49), 48, + anon_sym_BOOL, + anon_sym_Bool, + anon_sym_INT, + anon_sym_Int, + anon_sym_int, + anon_sym_DINT, + anon_sym_DInt, + anon_sym_dint, + anon_sym_SINT, + anon_sym_SInt, + anon_sym_sint, + anon_sym_USINT, + anon_sym_USInt, + anon_sym_usint, + anon_sym_UINT, + anon_sym_UInt, + anon_sym_uint, + anon_sym_WORD, + anon_sym_Word, + anon_sym_word, + anon_sym_DWORD, + anon_sym_DWord, + anon_sym_dword, + anon_sym_BYTE, + anon_sym_Byte, + anon_sym_byte, + anon_sym_REAL, + anon_sym_Real, + anon_sym_real, + anon_sym_LREAL, + anon_sym_LReal, + anon_sym_lreal, + anon_sym_TIME, + anon_sym_Time, + anon_sym_time, + anon_sym_TOD, + anon_sym_Tod, + anon_sym_tod, + anon_sym_DT, + anon_sym_Dt, + anon_sym_dt, + anon_sym_Char, + anon_sym_CHAR, + anon_sym_char, + anon_sym_WChar, + anon_sym_WCHAR, + anon_sym_wchar, + sym_identifier, + [395] = 28, + ACTIONS(7), 1, + anon_sym_ORGANIZATION_BLOCK, + ACTIONS(9), 1, + anon_sym_FUNCTION_BLOCK, + ACTIONS(11), 1, + anon_sym_FUNCTION, + ACTIONS(13), 1, + anon_sym_SEMI, + ACTIONS(17), 1, + anon_sym_VAR, + ACTIONS(19), 1, + anon_sym_VAR_TEMP, + ACTIONS(21), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(23), 1, + anon_sym_VAR_RETAIN, + ACTIONS(25), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(29), 1, + anon_sym_IF, + ACTIONS(31), 1, + anon_sym_CASE, + ACTIONS(33), 1, + anon_sym_FOR, + ACTIONS(35), 1, + anon_sym_WHILE, + ACTIONS(37), 1, + anon_sym_REPEAT, + ACTIONS(39), 1, + anon_sym_REGION, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(45), 1, + sym_identifier, + ACTIONS(65), 1, + ts_builtin_sym_end, + STATE(1536), 1, + sym_string, + STATE(1544), 1, + sym_lvalue, + ACTIONS(47), 2, + sym_exit_statement, + sym_continue_statement, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(15), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(8), 5, + sym_organization_block, + sym_function_block, + sym_function, + sym_statement, + aux_sym_source_file_repeat1, + STATE(356), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [505] = 28, + ACTIONS(67), 1, + ts_builtin_sym_end, + ACTIONS(69), 1, + anon_sym_ORGANIZATION_BLOCK, + ACTIONS(72), 1, + anon_sym_FUNCTION_BLOCK, + ACTIONS(75), 1, + anon_sym_FUNCTION, + ACTIONS(78), 1, + anon_sym_SEMI, + ACTIONS(84), 1, + anon_sym_VAR, + ACTIONS(87), 1, + anon_sym_VAR_TEMP, + ACTIONS(90), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(93), 1, + anon_sym_VAR_RETAIN, + ACTIONS(96), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(99), 1, + anon_sym_POUND, + ACTIONS(102), 1, + anon_sym_IF, + ACTIONS(105), 1, + anon_sym_CASE, + ACTIONS(108), 1, + anon_sym_FOR, + ACTIONS(111), 1, + anon_sym_WHILE, + ACTIONS(114), 1, + anon_sym_REPEAT, + ACTIONS(117), 1, + anon_sym_REGION, + ACTIONS(120), 1, + anon_sym_SQUOTE, + ACTIONS(123), 1, + anon_sym_DQUOTE, + ACTIONS(126), 1, + sym_identifier, + STATE(1536), 1, + sym_string, + STATE(1544), 1, + sym_lvalue, + ACTIONS(129), 2, + sym_exit_statement, + sym_continue_statement, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(81), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(8), 5, + sym_organization_block, + sym_function_block, + sym_function, + sym_statement, + aux_sym_source_file_repeat1, + STATE(356), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [615] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(148), 1, + anon_sym_END_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1726), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(25), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1202), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [726] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(168), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1679), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(19), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1206), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [837] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(170), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1688), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(12), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1217), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [948] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(172), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1628), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1203), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1059] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(174), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1630), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1197), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1170] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(176), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1656), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(13), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1198), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1281] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(178), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1613), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1200), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1392] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(180), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1730), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(15), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1209), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1503] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(182), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1622), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1199), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1614] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(184), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1719), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(17), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1207), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1725] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(186), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1702), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1210), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1836] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(188), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1617), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(21), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1214), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [1947] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(190), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1634), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1208), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2058] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(192), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1720), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(23), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1196), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2169] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(194), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1674), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1201), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2280] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(196), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1620), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1215), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2391] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(198), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1631), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1195), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2502] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(200), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1655), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(27), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1211), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2613] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(202), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1716), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1205), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2724] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(204), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1672), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(29), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1213), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2835] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(206), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1687), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1204), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [2946] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(208), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1607), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(24), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1212), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3057] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(210), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1710), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(32), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1194), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3168] = 29, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(150), 1, + anon_sym_ELSIF, + ACTIONS(152), 1, + anon_sym_ELSE, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + ACTIONS(212), 1, + anon_sym_END_IF, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + STATE(1733), 1, + sym_else_clause, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + STATE(1216), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3279] = 26, + ACTIONS(214), 1, + anon_sym_SEMI, + ACTIONS(220), 1, + anon_sym_VAR, + ACTIONS(223), 1, + anon_sym_VAR_TEMP, + ACTIONS(226), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(229), 1, + anon_sym_VAR_RETAIN, + ACTIONS(232), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(238), 1, + anon_sym_IF, + ACTIONS(243), 1, + anon_sym_CASE, + ACTIONS(246), 1, + anon_sym_FOR, + ACTIONS(249), 1, + anon_sym_WHILE, + ACTIONS(252), 1, + anon_sym_REPEAT, + ACTIONS(255), 1, + anon_sym_REGION, + ACTIONS(258), 1, + sym_number, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(266), 1, + sym_identifier, + STATE(1474), 1, + sym_string, + STATE(1543), 1, + sym_lvalue, + ACTIONS(241), 2, + anon_sym_ELSE, + anon_sym_END_CASE, + ACTIONS(269), 2, + sym_exit_statement, + sym_continue_statement, + STATE(33), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(217), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(462), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3381] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(272), 1, + anon_sym_SEMI, + ACTIONS(278), 1, + anon_sym_VAR, + ACTIONS(281), 1, + anon_sym_VAR_TEMP, + ACTIONS(284), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(287), 1, + anon_sym_VAR_RETAIN, + ACTIONS(290), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(293), 1, + anon_sym_IF, + ACTIONS(296), 1, + anon_sym_CASE, + ACTIONS(299), 1, + anon_sym_FOR, + ACTIONS(302), 1, + anon_sym_WHILE, + ACTIONS(305), 1, + anon_sym_REPEAT, + ACTIONS(308), 1, + anon_sym_REGION, + ACTIONS(311), 1, + sym_identifier, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + ACTIONS(314), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(241), 3, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + ACTIONS(275), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3481] = 26, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(317), 1, + anon_sym_SEMI, + ACTIONS(321), 1, + anon_sym_VAR, + ACTIONS(323), 1, + anon_sym_VAR_TEMP, + ACTIONS(325), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(327), 1, + anon_sym_VAR_RETAIN, + ACTIONS(329), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(331), 1, + anon_sym_POUND, + ACTIONS(334), 1, + anon_sym_IF, + ACTIONS(338), 1, + anon_sym_CASE, + ACTIONS(340), 1, + anon_sym_FOR, + ACTIONS(342), 1, + anon_sym_WHILE, + ACTIONS(344), 1, + anon_sym_REPEAT, + ACTIONS(346), 1, + anon_sym_REGION, + ACTIONS(348), 1, + sym_number, + ACTIONS(350), 1, + sym_identifier, + STATE(1474), 1, + sym_string, + STATE(1543), 1, + sym_lvalue, + ACTIONS(336), 2, + anon_sym_ELSE, + anon_sym_END_CASE, + ACTIONS(353), 2, + sym_exit_statement, + sym_continue_statement, + STATE(38), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(319), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(462), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3583] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(34), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + ACTIONS(355), 3, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3683] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(132), 1, + anon_sym_SEMI, + ACTIONS(136), 1, + anon_sym_VAR, + ACTIONS(138), 1, + anon_sym_VAR_TEMP, + ACTIONS(140), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(142), 1, + anon_sym_VAR_RETAIN, + ACTIONS(144), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(146), 1, + anon_sym_IF, + ACTIONS(154), 1, + anon_sym_CASE, + ACTIONS(156), 1, + anon_sym_FOR, + ACTIONS(158), 1, + anon_sym_WHILE, + ACTIONS(160), 1, + anon_sym_REPEAT, + ACTIONS(162), 1, + anon_sym_REGION, + ACTIONS(164), 1, + sym_identifier, + STATE(1439), 1, + sym_string, + STATE(1546), 1, + sym_lvalue, + ACTIONS(166), 2, + sym_exit_statement, + sym_continue_statement, + STATE(36), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(134), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + ACTIONS(357), 3, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(376), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3783] = 26, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(317), 1, + anon_sym_SEMI, + ACTIONS(321), 1, + anon_sym_VAR, + ACTIONS(323), 1, + anon_sym_VAR_TEMP, + ACTIONS(325), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(327), 1, + anon_sym_VAR_RETAIN, + ACTIONS(329), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(334), 1, + anon_sym_IF, + ACTIONS(338), 1, + anon_sym_CASE, + ACTIONS(340), 1, + anon_sym_FOR, + ACTIONS(342), 1, + anon_sym_WHILE, + ACTIONS(344), 1, + anon_sym_REPEAT, + ACTIONS(346), 1, + anon_sym_REGION, + ACTIONS(359), 1, + anon_sym_POUND, + ACTIONS(364), 1, + sym_number, + ACTIONS(366), 1, + sym_identifier, + STATE(1474), 1, + sym_string, + STATE(1543), 1, + sym_lvalue, + ACTIONS(353), 2, + sym_exit_statement, + sym_continue_statement, + ACTIONS(362), 2, + anon_sym_ELSE, + anon_sym_END_CASE, + STATE(33), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(319), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(462), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3885] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(395), 1, + anon_sym_END_REGION, + ACTIONS(397), 1, + sym_identifier, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [3983] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(401), 1, + anon_sym_END_FUNCTION, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4081] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(433), 1, + anon_sym_SEMI, + ACTIONS(437), 1, + anon_sym_VAR, + ACTIONS(439), 1, + anon_sym_VAR_TEMP, + ACTIONS(441), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(443), 1, + anon_sym_VAR_RETAIN, + ACTIONS(445), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(447), 1, + anon_sym_IF, + ACTIONS(449), 1, + anon_sym_END_IF, + ACTIONS(451), 1, + anon_sym_CASE, + ACTIONS(453), 1, + anon_sym_FOR, + ACTIONS(455), 1, + anon_sym_WHILE, + ACTIONS(457), 1, + anon_sym_REPEAT, + ACTIONS(459), 1, + anon_sym_REGION, + ACTIONS(461), 1, + sym_identifier, + STATE(1457), 1, + sym_string, + STATE(1560), 1, + sym_lvalue, + ACTIONS(463), 2, + sym_exit_statement, + sym_continue_statement, + STATE(99), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(435), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(510), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4179] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(465), 1, + anon_sym_END_ORGANIZATION_BLOCK, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(48), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4277] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(465), 1, + anon_sym_END_ORGANIZATION_BLOCK, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4375] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(497), 1, + anon_sym_END_FUNCTION_BLOCK, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(50), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4473] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(497), 1, + anon_sym_END_FUNCTION_BLOCK, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4571] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(529), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(52), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4669] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(529), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4767] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(531), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4865] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(531), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(56), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [4963] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(533), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5061] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(533), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(58), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5159] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(535), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5257] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(535), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(60), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5355] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(537), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(132), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5453] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(559), 1, + anon_sym_END_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(62), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5551] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(571), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5649] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(571), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(64), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5747] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(573), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5845] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(573), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(66), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [5943] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(575), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6041] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(575), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(68), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6139] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(577), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6237] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(579), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(70), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6335] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(579), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6433] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(581), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(72), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6531] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(581), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6629] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(583), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(74), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6727] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(583), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6825] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(585), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(77), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [6923] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(587), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7021] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(587), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(78), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7119] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(589), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7217] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(589), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(80), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7315] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(591), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7413] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(591), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(82), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7511] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(593), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(142), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7609] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(595), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7707] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(597), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7805] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(597), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(84), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [7903] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(599), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8001] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(599), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(85), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8099] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(601), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8197] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(601), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(86), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8295] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(603), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8393] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(605), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8491] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(607), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8589] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(607), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(88), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8687] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(609), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8785] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(609), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(90), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8883] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(611), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [8981] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_REGION, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(613), 1, + anon_sym_SEMI, + ACTIONS(619), 1, + anon_sym_VAR, + ACTIONS(622), 1, + anon_sym_VAR_TEMP, + ACTIONS(625), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(628), 1, + anon_sym_VAR_RETAIN, + ACTIONS(631), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(634), 1, + anon_sym_IF, + ACTIONS(637), 1, + anon_sym_CASE, + ACTIONS(640), 1, + anon_sym_FOR, + ACTIONS(643), 1, + anon_sym_WHILE, + ACTIONS(646), 1, + anon_sym_REPEAT, + ACTIONS(649), 1, + anon_sym_REGION, + ACTIONS(652), 1, + sym_identifier, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(655), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(616), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9079] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(658), 1, + anon_sym_SEMI, + ACTIONS(662), 1, + anon_sym_VAR, + ACTIONS(664), 1, + anon_sym_VAR_TEMP, + ACTIONS(666), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(668), 1, + anon_sym_VAR_RETAIN, + ACTIONS(670), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(672), 1, + anon_sym_IF, + ACTIONS(674), 1, + anon_sym_CASE, + ACTIONS(676), 1, + anon_sym_END_CASE, + ACTIONS(678), 1, + anon_sym_FOR, + ACTIONS(680), 1, + anon_sym_WHILE, + ACTIONS(682), 1, + anon_sym_REPEAT, + ACTIONS(684), 1, + anon_sym_REGION, + ACTIONS(686), 1, + sym_identifier, + STATE(1464), 1, + sym_string, + STATE(1539), 1, + sym_lvalue, + ACTIONS(688), 2, + sym_exit_statement, + sym_continue_statement, + STATE(93), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(660), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(555), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9177] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(449), 1, + anon_sym_END_CASE, + ACTIONS(658), 1, + anon_sym_SEMI, + ACTIONS(662), 1, + anon_sym_VAR, + ACTIONS(664), 1, + anon_sym_VAR_TEMP, + ACTIONS(666), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(668), 1, + anon_sym_VAR_RETAIN, + ACTIONS(670), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(672), 1, + anon_sym_IF, + ACTIONS(674), 1, + anon_sym_CASE, + ACTIONS(678), 1, + anon_sym_FOR, + ACTIONS(680), 1, + anon_sym_WHILE, + ACTIONS(682), 1, + anon_sym_REPEAT, + ACTIONS(684), 1, + anon_sym_REGION, + ACTIONS(686), 1, + sym_identifier, + STATE(1464), 1, + sym_string, + STATE(1539), 1, + sym_lvalue, + ACTIONS(688), 2, + sym_exit_statement, + sym_continue_statement, + STATE(100), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(660), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(555), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9275] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_ORGANIZATION_BLOCK, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(690), 1, + anon_sym_SEMI, + ACTIONS(696), 1, + anon_sym_VAR, + ACTIONS(699), 1, + anon_sym_VAR_TEMP, + ACTIONS(702), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(705), 1, + anon_sym_VAR_RETAIN, + ACTIONS(708), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(711), 1, + anon_sym_IF, + ACTIONS(714), 1, + anon_sym_CASE, + ACTIONS(717), 1, + anon_sym_FOR, + ACTIONS(720), 1, + anon_sym_WHILE, + ACTIONS(723), 1, + anon_sym_REPEAT, + ACTIONS(726), 1, + anon_sym_REGION, + ACTIONS(729), 1, + sym_identifier, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(732), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(693), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9373] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_FUNCTION_BLOCK, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(735), 1, + anon_sym_SEMI, + ACTIONS(741), 1, + anon_sym_VAR, + ACTIONS(744), 1, + anon_sym_VAR_TEMP, + ACTIONS(747), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(750), 1, + anon_sym_VAR_RETAIN, + ACTIONS(753), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(756), 1, + anon_sym_IF, + ACTIONS(759), 1, + anon_sym_CASE, + ACTIONS(762), 1, + anon_sym_FOR, + ACTIONS(765), 1, + anon_sym_WHILE, + ACTIONS(768), 1, + anon_sym_REPEAT, + ACTIONS(771), 1, + anon_sym_REGION, + ACTIONS(774), 1, + sym_identifier, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(777), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(738), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9471] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_FUNCTION, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(780), 1, + anon_sym_SEMI, + ACTIONS(786), 1, + anon_sym_VAR, + ACTIONS(789), 1, + anon_sym_VAR_TEMP, + ACTIONS(792), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(795), 1, + anon_sym_VAR_RETAIN, + ACTIONS(798), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(801), 1, + anon_sym_IF, + ACTIONS(804), 1, + anon_sym_CASE, + ACTIONS(807), 1, + anon_sym_FOR, + ACTIONS(810), 1, + anon_sym_WHILE, + ACTIONS(813), 1, + anon_sym_REPEAT, + ACTIONS(816), 1, + anon_sym_REGION, + ACTIONS(819), 1, + sym_identifier, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(822), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(783), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9569] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(825), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(152), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9667] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_WHILE, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(827), 1, + anon_sym_SEMI, + ACTIONS(833), 1, + anon_sym_VAR, + ACTIONS(836), 1, + anon_sym_VAR_TEMP, + ACTIONS(839), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(842), 1, + anon_sym_VAR_RETAIN, + ACTIONS(845), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(848), 1, + anon_sym_IF, + ACTIONS(851), 1, + anon_sym_CASE, + ACTIONS(854), 1, + anon_sym_FOR, + ACTIONS(857), 1, + anon_sym_WHILE, + ACTIONS(860), 1, + anon_sym_REPEAT, + ACTIONS(863), 1, + anon_sym_REGION, + ACTIONS(866), 1, + sym_identifier, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(869), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(830), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9765] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_IF, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(872), 1, + anon_sym_SEMI, + ACTIONS(878), 1, + anon_sym_VAR, + ACTIONS(881), 1, + anon_sym_VAR_TEMP, + ACTIONS(884), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(887), 1, + anon_sym_VAR_RETAIN, + ACTIONS(890), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(893), 1, + anon_sym_IF, + ACTIONS(896), 1, + anon_sym_CASE, + ACTIONS(899), 1, + anon_sym_FOR, + ACTIONS(902), 1, + anon_sym_WHILE, + ACTIONS(905), 1, + anon_sym_REPEAT, + ACTIONS(908), 1, + anon_sym_REGION, + ACTIONS(911), 1, + sym_identifier, + STATE(1457), 1, + sym_string, + STATE(1560), 1, + sym_lvalue, + ACTIONS(914), 2, + sym_exit_statement, + sym_continue_statement, + STATE(99), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(875), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(510), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9863] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_CASE, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(917), 1, + anon_sym_SEMI, + ACTIONS(923), 1, + anon_sym_VAR, + ACTIONS(926), 1, + anon_sym_VAR_TEMP, + ACTIONS(929), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(932), 1, + anon_sym_VAR_RETAIN, + ACTIONS(935), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(938), 1, + anon_sym_IF, + ACTIONS(941), 1, + anon_sym_CASE, + ACTIONS(944), 1, + anon_sym_FOR, + ACTIONS(947), 1, + anon_sym_WHILE, + ACTIONS(950), 1, + anon_sym_REPEAT, + ACTIONS(953), 1, + anon_sym_REGION, + ACTIONS(956), 1, + sym_identifier, + STATE(1464), 1, + sym_string, + STATE(1539), 1, + sym_lvalue, + ACTIONS(959), 2, + sym_exit_statement, + sym_continue_statement, + STATE(100), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(920), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(555), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [9961] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_END_FOR, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(962), 1, + anon_sym_SEMI, + ACTIONS(968), 1, + anon_sym_VAR, + ACTIONS(971), 1, + anon_sym_VAR_TEMP, + ACTIONS(974), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(977), 1, + anon_sym_VAR_RETAIN, + ACTIONS(980), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(983), 1, + anon_sym_IF, + ACTIONS(986), 1, + anon_sym_CASE, + ACTIONS(989), 1, + anon_sym_FOR, + ACTIONS(992), 1, + anon_sym_WHILE, + ACTIONS(995), 1, + anon_sym_REPEAT, + ACTIONS(998), 1, + anon_sym_REGION, + ACTIONS(1001), 1, + sym_identifier, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(1004), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(965), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10059] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1007), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(105), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10157] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1031), 1, + anon_sym_END_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(179), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10255] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1041), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(107), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10353] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1043), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10451] = 25, + ACTIONS(235), 1, + anon_sym_POUND, + ACTIONS(241), 1, + anon_sym_UNTIL, + ACTIONS(260), 1, + anon_sym_SQUOTE, + ACTIONS(263), 1, + anon_sym_DQUOTE, + ACTIONS(1045), 1, + anon_sym_SEMI, + ACTIONS(1051), 1, + anon_sym_VAR, + ACTIONS(1054), 1, + anon_sym_VAR_TEMP, + ACTIONS(1057), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1060), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1063), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1066), 1, + anon_sym_IF, + ACTIONS(1069), 1, + anon_sym_CASE, + ACTIONS(1072), 1, + anon_sym_FOR, + ACTIONS(1075), 1, + anon_sym_WHILE, + ACTIONS(1078), 1, + anon_sym_REPEAT, + ACTIONS(1081), 1, + anon_sym_REGION, + ACTIONS(1084), 1, + sym_identifier, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1087), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1048), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10549] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1090), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10647] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1092), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(109), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10745] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1094), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10843] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1096), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(111), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [10941] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1098), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11039] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1100), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(39), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11137] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1102), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(116), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11235] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1128), 1, + anon_sym_UNTIL, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(162), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11333] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1136), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11431] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1138), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11529] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1140), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(229), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11627] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(401), 1, + anon_sym_END_FUNCTION, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(47), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11725] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1142), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(120), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11823] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1144), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [11921] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1146), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(123), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12019] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1148), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(124), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12117] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1150), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12215] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1152), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12313] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1154), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(126), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12411] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1156), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12509] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1158), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(128), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12607] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1160), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12705] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1162), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(131), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12803] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1164), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(133), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12901] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1166), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [12999] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(1168), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13097] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1170), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13195] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1172), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(135), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13293] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1174), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13391] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1176), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(137), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13489] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1178), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13587] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1180), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(141), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13685] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(1168), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(190), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13783] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1182), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(143), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13881] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1184), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [13979] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(1186), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14077] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1188), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14175] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1190), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(145), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14273] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1192), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14371] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1194), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(147), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14469] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1196), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14567] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1198), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(151), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14665] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(1186), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(200), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14763] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1200), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(153), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14861] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1202), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [14959] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(1204), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(96), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15057] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1206), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15155] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1208), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(155), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15253] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1210), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15351] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1212), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(157), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15449] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1214), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15547] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1216), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(161), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15645] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(403), 1, + anon_sym_SEMI, + ACTIONS(407), 1, + anon_sym_VAR, + ACTIONS(409), 1, + anon_sym_VAR_TEMP, + ACTIONS(411), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(413), 1, + anon_sym_VAR_RETAIN, + ACTIONS(415), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(417), 1, + anon_sym_IF, + ACTIONS(419), 1, + anon_sym_CASE, + ACTIONS(421), 1, + anon_sym_FOR, + ACTIONS(423), 1, + anon_sym_WHILE, + ACTIONS(425), 1, + anon_sym_REPEAT, + ACTIONS(427), 1, + anon_sym_REGION, + ACTIONS(429), 1, + sym_identifier, + ACTIONS(1204), 1, + anon_sym_END_FUNCTION, + STATE(1435), 1, + sym_string, + STATE(1563), 1, + sym_lvalue, + ACTIONS(431), 2, + sym_exit_statement, + sym_continue_statement, + STATE(40), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(405), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(740), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15743] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1218), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(163), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15841] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1220), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [15939] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1222), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16037] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1224), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16135] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1226), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(165), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16233] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1228), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16331] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1230), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(167), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16429] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1232), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16527] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1234), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(171), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16625] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(433), 1, + anon_sym_SEMI, + ACTIONS(437), 1, + anon_sym_VAR, + ACTIONS(439), 1, + anon_sym_VAR_TEMP, + ACTIONS(441), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(443), 1, + anon_sym_VAR_RETAIN, + ACTIONS(445), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(447), 1, + anon_sym_IF, + ACTIONS(451), 1, + anon_sym_CASE, + ACTIONS(453), 1, + anon_sym_FOR, + ACTIONS(455), 1, + anon_sym_WHILE, + ACTIONS(457), 1, + anon_sym_REPEAT, + ACTIONS(459), 1, + anon_sym_REGION, + ACTIONS(461), 1, + sym_identifier, + ACTIONS(676), 1, + anon_sym_END_IF, + STATE(1457), 1, + sym_string, + STATE(1560), 1, + sym_lvalue, + ACTIONS(463), 2, + sym_exit_statement, + sym_continue_statement, + STATE(41), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(435), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(510), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16723] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1236), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(173), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16821] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1238), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [16919] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1240), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(115), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17017] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1242), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17115] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1244), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(175), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17213] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1246), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17311] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1248), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(177), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17409] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1250), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17507] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1252), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(181), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17605] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1254), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17703] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1256), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(182), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17801] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1258), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17899] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1260), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [17997] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1262), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(184), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18095] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1264), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18193] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1266), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(186), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18291] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1268), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18389] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1270), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(189), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18487] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1272), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(191), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18585] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1274), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18683] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(1276), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(94), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18781] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1278), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18879] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1280), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(193), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [18977] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1282), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19075] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1284), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(195), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19173] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1286), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19271] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1288), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(199), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19369] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(467), 1, + anon_sym_SEMI, + ACTIONS(471), 1, + anon_sym_VAR, + ACTIONS(473), 1, + anon_sym_VAR_TEMP, + ACTIONS(475), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(477), 1, + anon_sym_VAR_RETAIN, + ACTIONS(479), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(481), 1, + anon_sym_IF, + ACTIONS(483), 1, + anon_sym_CASE, + ACTIONS(485), 1, + anon_sym_FOR, + ACTIONS(487), 1, + anon_sym_WHILE, + ACTIONS(489), 1, + anon_sym_REPEAT, + ACTIONS(491), 1, + anon_sym_REGION, + ACTIONS(493), 1, + sym_identifier, + ACTIONS(1276), 1, + anon_sym_END_ORGANIZATION_BLOCK, + STATE(1418), 1, + sym_string, + STATE(1548), 1, + sym_lvalue, + ACTIONS(495), 2, + sym_exit_statement, + sym_continue_statement, + STATE(43), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(469), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(617), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19467] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1290), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(201), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19565] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(369), 1, + anon_sym_SEMI, + ACTIONS(373), 1, + anon_sym_VAR, + ACTIONS(375), 1, + anon_sym_VAR_TEMP, + ACTIONS(377), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(379), 1, + anon_sym_VAR_RETAIN, + ACTIONS(381), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(383), 1, + anon_sym_IF, + ACTIONS(385), 1, + anon_sym_CASE, + ACTIONS(387), 1, + anon_sym_FOR, + ACTIONS(389), 1, + anon_sym_WHILE, + ACTIONS(391), 1, + anon_sym_REPEAT, + ACTIONS(393), 1, + anon_sym_REGION, + ACTIONS(397), 1, + sym_identifier, + ACTIONS(1292), 1, + anon_sym_END_REGION, + STATE(1409), 1, + sym_string, + STATE(1541), 1, + sym_lvalue, + ACTIONS(399), 2, + sym_exit_statement, + sym_continue_statement, + STATE(91), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(371), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(485), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19663] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(1294), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(95), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19761] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1009), 1, + anon_sym_SEMI, + ACTIONS(1013), 1, + anon_sym_VAR, + ACTIONS(1015), 1, + anon_sym_VAR_TEMP, + ACTIONS(1017), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1019), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1021), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1023), 1, + anon_sym_IF, + ACTIONS(1025), 1, + anon_sym_CASE, + ACTIONS(1027), 1, + anon_sym_FOR, + ACTIONS(1029), 1, + anon_sym_WHILE, + ACTIONS(1033), 1, + anon_sym_REPEAT, + ACTIONS(1035), 1, + anon_sym_REGION, + ACTIONS(1037), 1, + sym_identifier, + ACTIONS(1296), 1, + anon_sym_END_WHILE, + STATE(1448), 1, + sym_string, + STATE(1553), 1, + sym_lvalue, + ACTIONS(1039), 2, + sym_exit_statement, + sym_continue_statement, + STATE(98), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1011), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(492), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19859] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1298), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(203), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [19957] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1300), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20055] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1302), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(205), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20153] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1304), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20251] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(499), 1, + anon_sym_SEMI, + ACTIONS(503), 1, + anon_sym_VAR, + ACTIONS(505), 1, + anon_sym_VAR_TEMP, + ACTIONS(507), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(509), 1, + anon_sym_VAR_RETAIN, + ACTIONS(511), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(513), 1, + anon_sym_IF, + ACTIONS(515), 1, + anon_sym_CASE, + ACTIONS(517), 1, + anon_sym_FOR, + ACTIONS(519), 1, + anon_sym_WHILE, + ACTIONS(521), 1, + anon_sym_REPEAT, + ACTIONS(523), 1, + anon_sym_REGION, + ACTIONS(525), 1, + sym_identifier, + ACTIONS(1294), 1, + anon_sym_END_FUNCTION_BLOCK, + STATE(1426), 1, + sym_string, + STATE(1556), 1, + sym_lvalue, + ACTIONS(527), 2, + sym_exit_statement, + sym_continue_statement, + STATE(45), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(501), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(689), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20349] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1306), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(208), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20447] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1308), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20545] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1310), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(210), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20643] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1312), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20741] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1314), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(212), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20839] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1316), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [20937] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1318), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(214), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21035] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1320), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21133] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1322), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(216), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21231] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1324), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21329] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1326), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(218), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21427] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1328), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21525] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1330), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(220), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21623] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1332), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21721] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1334), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(222), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21819] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1336), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [21917] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1338), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(224), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22015] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1340), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22113] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1342), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(226), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22211] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1344), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22309] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1346), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(228), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22407] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(1104), 1, + anon_sym_SEMI, + ACTIONS(1108), 1, + anon_sym_VAR, + ACTIONS(1110), 1, + anon_sym_VAR_TEMP, + ACTIONS(1112), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(1114), 1, + anon_sym_VAR_RETAIN, + ACTIONS(1116), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(1118), 1, + anon_sym_IF, + ACTIONS(1120), 1, + anon_sym_CASE, + ACTIONS(1122), 1, + anon_sym_FOR, + ACTIONS(1124), 1, + anon_sym_WHILE, + ACTIONS(1126), 1, + anon_sym_REPEAT, + ACTIONS(1130), 1, + anon_sym_REGION, + ACTIONS(1132), 1, + sym_identifier, + ACTIONS(1348), 1, + anon_sym_UNTIL, + STATE(1399), 1, + sym_string, + STATE(1557), 1, + sym_lvalue, + ACTIONS(1134), 2, + sym_exit_statement, + sym_continue_statement, + STATE(106), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1106), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(752), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22505] = 25, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(539), 1, + anon_sym_SEMI, + ACTIONS(543), 1, + anon_sym_VAR, + ACTIONS(545), 1, + anon_sym_VAR_TEMP, + ACTIONS(547), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(549), 1, + anon_sym_VAR_RETAIN, + ACTIONS(551), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(553), 1, + anon_sym_IF, + ACTIONS(555), 1, + anon_sym_CASE, + ACTIONS(557), 1, + anon_sym_FOR, + ACTIONS(561), 1, + anon_sym_WHILE, + ACTIONS(563), 1, + anon_sym_REPEAT, + ACTIONS(565), 1, + anon_sym_REGION, + ACTIONS(567), 1, + sym_identifier, + ACTIONS(1350), 1, + anon_sym_END_FOR, + STATE(1482), 1, + sym_string, + STATE(1550), 1, + sym_lvalue, + ACTIONS(569), 2, + sym_exit_statement, + sym_continue_statement, + STATE(101), 2, + sym_statement, + aux_sym_organization_block_repeat2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(541), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1554), 4, + sym_function_name, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(641), 14, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + sym_empty_statement, + sym_assignment, + sym_if_statement, + sym_case_statement, + sym_for_statement, + sym_while_statement, + sym_repeat_statement, + sym_region_statement, + sym_function_call, + [22603] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1354), 6, + anon_sym_EQ, + anon_sym_VAR, + anon_sym_SLASH, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1352), 36, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COLON_EQ, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_DOT, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [22655] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1358), 6, + anon_sym_EQ, + anon_sym_VAR, + anon_sym_SLASH, + anon_sym_LPAREN, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1356), 36, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COLON_EQ, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_DOT, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [22707] = 10, + ACTIONS(1364), 1, + anon_sym_SLASH, + ACTIONS(1366), 1, + anon_sym_DASH, + ACTIONS(1368), 1, + anon_sym_SQUOTE, + ACTIONS(1371), 1, + anon_sym_DQUOTE, + ACTIONS(1374), 1, + sym_identifier, + STATE(299), 1, + sym_region_name, + STATE(240), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 3, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1362), 19, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [22761] = 10, + ACTIONS(1364), 1, + anon_sym_SLASH, + ACTIONS(1366), 1, + anon_sym_DASH, + ACTIONS(1381), 1, + anon_sym_SQUOTE, + ACTIONS(1384), 1, + anon_sym_DQUOTE, + ACTIONS(1387), 1, + sym_identifier, + STATE(350), 1, + sym_region_name, + STATE(240), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1377), 3, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1379), 19, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [22815] = 8, + ACTIONS(1397), 1, + anon_sym_DASH, + ACTIONS(1400), 1, + anon_sym_SQUOTE, + ACTIONS(1403), 1, + anon_sym_DQUOTE, + ACTIONS(1394), 2, + anon_sym_SLASH, + sym_identifier, + STATE(234), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1390), 3, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1392), 19, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [22864] = 10, + ACTIONS(1406), 1, + anon_sym_SLASH, + ACTIONS(1408), 1, + anon_sym_DASH, + ACTIONS(1410), 1, + anon_sym_SQUOTE, + ACTIONS(1413), 1, + anon_sym_DQUOTE, + ACTIONS(1416), 1, + sym_identifier, + STATE(413), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(242), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [22917] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1419), 5, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1421), 24, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_DOT, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [22956] = 10, + ACTIONS(1406), 1, + anon_sym_SLASH, + ACTIONS(1408), 1, + anon_sym_DASH, + ACTIONS(1423), 1, + anon_sym_SQUOTE, + ACTIONS(1426), 1, + anon_sym_DQUOTE, + ACTIONS(1429), 1, + sym_identifier, + STATE(405), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(242), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23009] = 10, + ACTIONS(1432), 1, + anon_sym_SLASH, + ACTIONS(1434), 1, + anon_sym_DASH, + ACTIONS(1436), 1, + anon_sym_SQUOTE, + ACTIONS(1439), 1, + anon_sym_DQUOTE, + ACTIONS(1442), 1, + sym_identifier, + STATE(378), 1, + sym_region_name, + STATE(243), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 3, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23062] = 10, + ACTIONS(1432), 1, + anon_sym_SLASH, + ACTIONS(1434), 1, + anon_sym_DASH, + ACTIONS(1445), 1, + anon_sym_SQUOTE, + ACTIONS(1448), 1, + anon_sym_DQUOTE, + ACTIONS(1451), 1, + sym_identifier, + STATE(399), 1, + sym_region_name, + STATE(243), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1377), 3, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + ACTIONS(1379), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23115] = 9, + ACTIONS(1458), 1, + anon_sym_SLASH, + ACTIONS(1460), 1, + anon_sym_DASH, + ACTIONS(1462), 1, + anon_sym_SQUOTE, + ACTIONS(1465), 1, + anon_sym_DQUOTE, + ACTIONS(1468), 1, + sym_identifier, + STATE(234), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1454), 3, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1456), 19, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23166] = 8, + ACTIONS(1474), 1, + anon_sym_DASH, + ACTIONS(1477), 1, + anon_sym_SQUOTE, + ACTIONS(1480), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1471), 2, + anon_sym_SLASH, + sym_identifier, + STATE(241), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23214] = 9, + ACTIONS(1483), 1, + anon_sym_SLASH, + ACTIONS(1485), 1, + anon_sym_DASH, + ACTIONS(1487), 1, + anon_sym_SQUOTE, + ACTIONS(1490), 1, + anon_sym_DQUOTE, + ACTIONS(1493), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(241), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23264] = 9, + ACTIONS(1496), 1, + anon_sym_SLASH, + ACTIONS(1498), 1, + anon_sym_DASH, + ACTIONS(1500), 1, + anon_sym_SQUOTE, + ACTIONS(1503), 1, + anon_sym_DQUOTE, + ACTIONS(1506), 1, + sym_identifier, + STATE(246), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1454), 3, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + ACTIONS(1456), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23314] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1509), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1511), 24, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_DOT, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [23352] = 5, + ACTIONS(1519), 1, + anon_sym_LPAREN, + ACTIONS(1517), 2, + anon_sym_LBRACK, + anon_sym_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1513), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [23394] = 8, + ACTIONS(1524), 1, + anon_sym_DASH, + ACTIONS(1527), 1, + anon_sym_SQUOTE, + ACTIONS(1530), 1, + anon_sym_DQUOTE, + ACTIONS(1521), 2, + anon_sym_SLASH, + sym_identifier, + STATE(246), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1390), 3, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + ACTIONS(1392), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23442] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1533), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1535), 24, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_DOT, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [23480] = 5, + ACTIONS(1519), 1, + anon_sym_LPAREN, + ACTIONS(1537), 2, + anon_sym_LBRACK, + anon_sym_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1513), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [23522] = 10, + ACTIONS(1539), 1, + anon_sym_SLASH, + ACTIONS(1541), 1, + anon_sym_DASH, + ACTIONS(1543), 1, + anon_sym_SQUOTE, + ACTIONS(1546), 1, + anon_sym_DQUOTE, + ACTIONS(1549), 1, + sym_identifier, + STATE(543), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(271), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23573] = 10, + ACTIONS(1552), 1, + anon_sym_SLASH, + ACTIONS(1554), 1, + anon_sym_DASH, + ACTIONS(1556), 1, + anon_sym_SQUOTE, + ACTIONS(1559), 1, + anon_sym_DQUOTE, + ACTIONS(1562), 1, + sym_identifier, + STATE(812), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(281), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23624] = 4, + ACTIONS(1537), 2, + anon_sym_LBRACK, + anon_sym_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1513), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [23663] = 10, + ACTIONS(1565), 1, + anon_sym_SLASH, + ACTIONS(1567), 1, + anon_sym_DASH, + ACTIONS(1569), 1, + anon_sym_SQUOTE, + ACTIONS(1572), 1, + anon_sym_DQUOTE, + ACTIONS(1575), 1, + sym_identifier, + STATE(580), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(282), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23714] = 10, + ACTIONS(1578), 1, + anon_sym_SLASH, + ACTIONS(1580), 1, + anon_sym_DASH, + ACTIONS(1582), 1, + anon_sym_SQUOTE, + ACTIONS(1585), 1, + anon_sym_DQUOTE, + ACTIONS(1588), 1, + sym_identifier, + STATE(720), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(291), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23765] = 10, + ACTIONS(1565), 1, + anon_sym_SLASH, + ACTIONS(1567), 1, + anon_sym_DASH, + ACTIONS(1591), 1, + anon_sym_SQUOTE, + ACTIONS(1594), 1, + anon_sym_DQUOTE, + ACTIONS(1597), 1, + sym_identifier, + STATE(589), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(282), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23816] = 10, + ACTIONS(1600), 1, + anon_sym_SLASH, + ACTIONS(1602), 1, + anon_sym_DASH, + ACTIONS(1604), 1, + anon_sym_SQUOTE, + ACTIONS(1607), 1, + anon_sym_DQUOTE, + ACTIONS(1610), 1, + sym_identifier, + STATE(764), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(285), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23867] = 10, + ACTIONS(1600), 1, + anon_sym_SLASH, + ACTIONS(1602), 1, + anon_sym_DASH, + ACTIONS(1613), 1, + anon_sym_SQUOTE, + ACTIONS(1616), 1, + anon_sym_DQUOTE, + ACTIONS(1619), 1, + sym_identifier, + STATE(773), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(285), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23918] = 10, + ACTIONS(1578), 1, + anon_sym_SLASH, + ACTIONS(1580), 1, + anon_sym_DASH, + ACTIONS(1622), 1, + anon_sym_SQUOTE, + ACTIONS(1625), 1, + anon_sym_DQUOTE, + ACTIONS(1628), 1, + sym_identifier, + STATE(728), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(291), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [23969] = 10, + ACTIONS(1552), 1, + anon_sym_SLASH, + ACTIONS(1554), 1, + anon_sym_DASH, + ACTIONS(1631), 1, + anon_sym_SQUOTE, + ACTIONS(1634), 1, + anon_sym_DQUOTE, + ACTIONS(1637), 1, + sym_identifier, + STATE(820), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(281), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24020] = 10, + ACTIONS(1640), 1, + anon_sym_SLASH, + ACTIONS(1642), 1, + anon_sym_DASH, + ACTIONS(1644), 1, + anon_sym_SQUOTE, + ACTIONS(1647), 1, + anon_sym_DQUOTE, + ACTIONS(1650), 1, + sym_identifier, + STATE(490), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(279), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24071] = 10, + ACTIONS(1653), 1, + anon_sym_SLASH, + ACTIONS(1655), 1, + anon_sym_DASH, + ACTIONS(1657), 1, + anon_sym_SQUOTE, + ACTIONS(1660), 1, + anon_sym_DQUOTE, + ACTIONS(1663), 1, + sym_identifier, + STATE(664), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(275), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24122] = 10, + ACTIONS(1653), 1, + anon_sym_SLASH, + ACTIONS(1655), 1, + anon_sym_DASH, + ACTIONS(1666), 1, + anon_sym_SQUOTE, + ACTIONS(1669), 1, + anon_sym_DQUOTE, + ACTIONS(1672), 1, + sym_identifier, + STATE(673), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(275), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24173] = 10, + ACTIONS(1640), 1, + anon_sym_SLASH, + ACTIONS(1642), 1, + anon_sym_DASH, + ACTIONS(1675), 1, + anon_sym_SQUOTE, + ACTIONS(1678), 1, + anon_sym_DQUOTE, + ACTIONS(1681), 1, + sym_identifier, + STATE(498), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(279), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24224] = 10, + ACTIONS(1539), 1, + anon_sym_SLASH, + ACTIONS(1541), 1, + anon_sym_DASH, + ACTIONS(1684), 1, + anon_sym_SQUOTE, + ACTIONS(1687), 1, + anon_sym_DQUOTE, + ACTIONS(1690), 1, + sym_identifier, + STATE(534), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(271), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24275] = 10, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(1695), 1, + anon_sym_DASH, + ACTIONS(1697), 1, + anon_sym_SQUOTE, + ACTIONS(1700), 1, + anon_sym_DQUOTE, + ACTIONS(1703), 1, + sym_identifier, + STATE(518), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_exit_statement, + sym_continue_statement, + [24326] = 10, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(1695), 1, + anon_sym_DASH, + ACTIONS(1706), 1, + anon_sym_SQUOTE, + ACTIONS(1709), 1, + anon_sym_DQUOTE, + ACTIONS(1712), 1, + sym_identifier, + STATE(569), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_exit_statement, + sym_continue_statement, + [24377] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 21, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [24414] = 10, + ACTIONS(1715), 1, + anon_sym_SLASH, + ACTIONS(1717), 1, + anon_sym_DASH, + ACTIONS(1719), 1, + anon_sym_SQUOTE, + ACTIONS(1722), 1, + anon_sym_DQUOTE, + ACTIONS(1725), 1, + sym_identifier, + STATE(652), 1, + sym_region_name, + ACTIONS(1360), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(286), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1362), 17, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24465] = 10, + ACTIONS(1715), 1, + anon_sym_SLASH, + ACTIONS(1717), 1, + anon_sym_DASH, + ACTIONS(1728), 1, + anon_sym_SQUOTE, + ACTIONS(1731), 1, + anon_sym_DQUOTE, + ACTIONS(1734), 1, + sym_identifier, + STATE(643), 1, + sym_region_name, + ACTIONS(1377), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(286), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1379), 17, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24516] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 6, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 21, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [24553] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 6, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [24589] = 9, + ACTIONS(1737), 1, + anon_sym_SLASH, + ACTIONS(1739), 1, + anon_sym_DASH, + ACTIONS(1741), 1, + anon_sym_SQUOTE, + ACTIONS(1744), 1, + anon_sym_DQUOTE, + ACTIONS(1747), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(276), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24637] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 21, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [24673] = 9, + ACTIONS(1750), 1, + anon_sym_SLASH, + ACTIONS(1752), 1, + anon_sym_DASH, + ACTIONS(1754), 1, + anon_sym_SQUOTE, + ACTIONS(1757), 1, + anon_sym_DQUOTE, + ACTIONS(1760), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(274), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_exit_statement, + sym_continue_statement, + [24721] = 8, + ACTIONS(1766), 1, + anon_sym_DASH, + ACTIONS(1769), 1, + anon_sym_SQUOTE, + ACTIONS(1772), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1763), 2, + anon_sym_SLASH, + sym_identifier, + STATE(274), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_exit_statement, + sym_continue_statement, + [24767] = 9, + ACTIONS(1775), 1, + anon_sym_SLASH, + ACTIONS(1777), 1, + anon_sym_DASH, + ACTIONS(1779), 1, + anon_sym_SQUOTE, + ACTIONS(1782), 1, + anon_sym_DQUOTE, + ACTIONS(1785), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(277), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24815] = 8, + ACTIONS(1791), 1, + anon_sym_DASH, + ACTIONS(1794), 1, + anon_sym_SQUOTE, + ACTIONS(1797), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1788), 2, + anon_sym_SLASH, + sym_identifier, + STATE(276), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24861] = 8, + ACTIONS(1803), 1, + anon_sym_DASH, + ACTIONS(1806), 1, + anon_sym_SQUOTE, + ACTIONS(1809), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1800), 2, + anon_sym_SLASH, + sym_identifier, + STATE(277), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24907] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 21, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [24943] = 9, + ACTIONS(1812), 1, + anon_sym_SLASH, + ACTIONS(1814), 1, + anon_sym_DASH, + ACTIONS(1816), 1, + anon_sym_SQUOTE, + ACTIONS(1819), 1, + anon_sym_DQUOTE, + ACTIONS(1822), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(289), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [24991] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 6, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25027] = 9, + ACTIONS(1825), 1, + anon_sym_SLASH, + ACTIONS(1827), 1, + anon_sym_DASH, + ACTIONS(1829), 1, + anon_sym_SQUOTE, + ACTIONS(1832), 1, + anon_sym_DQUOTE, + ACTIONS(1835), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(284), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25075] = 9, + ACTIONS(1838), 1, + anon_sym_SLASH, + ACTIONS(1840), 1, + anon_sym_DASH, + ACTIONS(1842), 1, + anon_sym_SQUOTE, + ACTIONS(1845), 1, + anon_sym_DQUOTE, + ACTIONS(1848), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(287), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25123] = 8, + ACTIONS(1854), 1, + anon_sym_DASH, + ACTIONS(1857), 1, + anon_sym_SQUOTE, + ACTIONS(1860), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1851), 2, + anon_sym_SLASH, + sym_identifier, + STATE(283), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25169] = 8, + ACTIONS(1866), 1, + anon_sym_DASH, + ACTIONS(1869), 1, + anon_sym_SQUOTE, + ACTIONS(1872), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1863), 2, + anon_sym_SLASH, + sym_identifier, + STATE(284), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25215] = 9, + ACTIONS(1875), 1, + anon_sym_SLASH, + ACTIONS(1877), 1, + anon_sym_DASH, + ACTIONS(1879), 1, + anon_sym_SQUOTE, + ACTIONS(1882), 1, + anon_sym_DQUOTE, + ACTIONS(1885), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(283), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25263] = 9, + ACTIONS(1888), 1, + anon_sym_SLASH, + ACTIONS(1890), 1, + anon_sym_DASH, + ACTIONS(1892), 1, + anon_sym_SQUOTE, + ACTIONS(1895), 1, + anon_sym_DQUOTE, + ACTIONS(1898), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(290), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25311] = 8, + ACTIONS(1904), 1, + anon_sym_DASH, + ACTIONS(1907), 1, + anon_sym_SQUOTE, + ACTIONS(1910), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1901), 2, + anon_sym_SLASH, + sym_identifier, + STATE(287), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25357] = 8, + ACTIONS(1916), 1, + anon_sym_DASH, + ACTIONS(1919), 1, + anon_sym_SQUOTE, + ACTIONS(1922), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1913), 2, + anon_sym_SLASH, + sym_identifier, + STATE(288), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25403] = 8, + ACTIONS(1928), 1, + anon_sym_DASH, + ACTIONS(1931), 1, + anon_sym_SQUOTE, + ACTIONS(1934), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1925), 2, + anon_sym_SLASH, + sym_identifier, + STATE(289), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25449] = 8, + ACTIONS(1940), 1, + anon_sym_DASH, + ACTIONS(1943), 1, + anon_sym_SQUOTE, + ACTIONS(1946), 1, + anon_sym_DQUOTE, + ACTIONS(1390), 2, + anon_sym_SEMI, + anon_sym_POUND, + ACTIONS(1937), 2, + anon_sym_SLASH, + sym_identifier, + STATE(290), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1392), 17, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25495] = 9, + ACTIONS(1949), 1, + anon_sym_SLASH, + ACTIONS(1951), 1, + anon_sym_DASH, + ACTIONS(1953), 1, + anon_sym_SQUOTE, + ACTIONS(1956), 1, + anon_sym_DQUOTE, + ACTIONS(1959), 1, + sym_identifier, + ACTIONS(1454), 2, + anon_sym_SEMI, + anon_sym_POUND, + STATE(288), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1456), 17, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_exit_statement, + sym_continue_statement, + [25543] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25578] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25613] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1972), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1974), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25648] = 4, + ACTIONS(1980), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + ts_builtin_sym_end, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25685] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25720] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1987), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1989), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25755] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25790] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25825] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25860] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2003), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2005), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25895] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2007), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2009), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25930] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2011), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2013), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [25965] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2015), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2017), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26000] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2019), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2021), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26035] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2023), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2025), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [26070] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1513), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [26105] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2027), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2029), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26140] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2031), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2033), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26175] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2035), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2037), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26210] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2039), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2041), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26245] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26280] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2047), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2049), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26315] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26350] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2057), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2059), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26385] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2061), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2063), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26420] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26455] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26490] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26525] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2081), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2083), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [26560] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2085), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2087), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [26595] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26630] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2093), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2095), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [26665] = 4, + ACTIONS(2097), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + ts_builtin_sym_end, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26702] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2100), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2102), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [26737] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26772] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2104), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2106), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26807] = 8, + ACTIONS(2108), 1, + anon_sym_EQ, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2110), 15, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + [26852] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26887] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2126), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2128), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26922] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26957] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [26992] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2142), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2144), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27027] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2108), 4, + anon_sym_EQ, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2110), 21, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_STAR, + anon_sym_MOD, + [27062] = 5, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2108), 3, + anon_sym_EQ, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2110), 19, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_DASH, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [27101] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27136] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27171] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27206] = 10, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2154), 1, + anon_sym_EQ, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2158), 1, + anon_sym_LT_GT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2110), 13, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_OR, + anon_sym_XOR, + [27255] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2160), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2162), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27290] = 9, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2154), 1, + anon_sym_EQ, + ACTIONS(2158), 1, + anon_sym_LT_GT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2110), 14, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + [27337] = 6, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2108), 3, + anon_sym_EQ, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2110), 17, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_OR, + anon_sym_XOR, + anon_sym_AND, + anon_sym_LT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [27378] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2164), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2166), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27413] = 4, + ACTIONS(2172), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 4, + ts_builtin_sym_end, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27450] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27485] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2179), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2181), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27520] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27555] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27590] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27625] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27660] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27695] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2203), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2205), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27730] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27765] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27800] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2211), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2213), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27835] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27870] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2219), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2221), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27905] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2223), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2225), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27940] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [27975] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28010] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28045] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2235), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2237), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28080] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2239), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2241), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28115] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2243), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2245), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28150] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2247), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2249), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28185] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28220] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28255] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2263), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2265), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28290] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2267), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2269), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28325] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2271), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2273), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28360] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28395] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28430] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28465] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2289), 5, + ts_builtin_sym_end, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2291), 20, + anon_sym_ORGANIZATION_BLOCK, + anon_sym_FUNCTION_BLOCK, + anon_sym_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28500] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2154), 1, + anon_sym_EQ, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2158), 1, + anon_sym_LT_GT, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2110), 12, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACK, + anon_sym_OF, + anon_sym_THEN, + anon_sym_TO, + anon_sym_BY, + anon_sym_DO, + anon_sym_END_REPEAT, + anon_sym_EQ_GT, + anon_sym_RPAREN, + anon_sym_OR, + [28551] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28585] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28619] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28653] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28687] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28721] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28755] = 4, + ACTIONS(2295), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28791] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28825] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28859] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28893] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28927] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28961] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [28995] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29029] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29063] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29097] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29131] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29165] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29199] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29233] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29267] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29301] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29335] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29369] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29403] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29437] = 4, + ACTIONS(2298), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29473] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29507] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29541] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29575] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29609] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29643] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29677] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29711] = 4, + ACTIONS(2301), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29747] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29781] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29815] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29849] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29883] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29917] = 4, + ACTIONS(2304), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29953] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [29987] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30021] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30055] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30089] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30123] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30157] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30191] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30225] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30259] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30293] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30327] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30361] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30395] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30429] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30463] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30497] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30531] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30565] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30599] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30633] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30667] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30701] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30735] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30769] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30803] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30837] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30871] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30905] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30939] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [30973] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31007] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31041] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31075] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31109] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31143] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31177] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31211] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31245] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31279] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31313] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31347] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31381] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31415] = 4, + ACTIONS(2307), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31451] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31485] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31519] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31553] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31587] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31621] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1352), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1354), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31655] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31689] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1356), 5, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_DASH, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1358), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_SLASH, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31723] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 5, + anon_sym_SEMI, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31757] = 4, + ACTIONS(2310), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 4, + anon_sym_POUND, + sym_number, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 19, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31793] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 20, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_ELSIF, + anon_sym_ELSE, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31827] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31859] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31891] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31923] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31955] = 4, + ACTIONS(2313), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [31989] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32021] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32053] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32085] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32117] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32149] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32181] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32213] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32245] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32277] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32309] = 4, + ACTIONS(2316), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32343] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32375] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32407] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32439] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32471] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32503] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32535] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32567] = 4, + ACTIONS(2319), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32601] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32633] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32665] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32697] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32729] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32761] = 4, + ACTIONS(2322), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32795] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32827] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32859] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32891] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32923] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32955] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [32987] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33019] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33051] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33083] = 4, + ACTIONS(2325), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33117] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33149] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33181] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33213] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33245] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33277] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33309] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33341] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33373] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33405] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33437] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33469] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33501] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33533] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33565] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33597] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33629] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33661] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33693] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33725] = 4, + ACTIONS(2328), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33759] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33791] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33823] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33855] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33887] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33919] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33951] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [33983] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34015] = 4, + ACTIONS(2331), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34049] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34081] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34113] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34145] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34177] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34209] = 4, + ACTIONS(2334), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34243] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34275] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34307] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34339] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34371] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34403] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34435] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34467] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34499] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34531] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34563] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34595] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34627] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34659] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34691] = 4, + ACTIONS(2337), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34725] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34757] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34789] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34821] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34853] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34885] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34917] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34949] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [34981] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35013] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35045] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35077] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35109] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35141] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35173] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35205] = 4, + ACTIONS(2340), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35239] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35271] = 4, + ACTIONS(2343), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35305] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35337] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35369] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35401] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35433] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35465] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35497] = 4, + ACTIONS(2346), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35531] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35563] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35595] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35627] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35659] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35691] = 4, + ACTIONS(2349), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35725] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35757] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35789] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35821] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35853] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35885] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35917] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35949] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [35981] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36013] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36045] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36077] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36109] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36141] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36173] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36205] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36237] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_END_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36269] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36301] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36333] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36365] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36397] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36429] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36461] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36493] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36525] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36557] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36589] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36621] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36653] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36685] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36717] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36749] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36781] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36813] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36845] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36877] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36909] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36941] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [36973] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37005] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37037] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37069] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37101] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37133] = 4, + ACTIONS(2352), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37167] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37199] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37231] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37263] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37295] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37327] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37359] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37391] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37423] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37455] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37487] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_END_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37519] = 4, + ACTIONS(2355), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37553] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37585] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37617] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37649] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37681] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37713] = 4, + ACTIONS(2358), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37747] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37779] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37811] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37843] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37875] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37907] = 4, + ACTIONS(2361), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37941] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [37973] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38005] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38037] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38069] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38101] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38133] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38165] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38197] = 4, + ACTIONS(2364), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38231] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38263] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38295] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38327] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38359] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38391] = 4, + ACTIONS(2367), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38425] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38457] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38489] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38521] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38553] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38585] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38617] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38649] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38681] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38713] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38745] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38777] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38809] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38841] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38873] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38905] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38937] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [38969] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39001] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39033] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39065] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39097] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39129] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39161] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39193] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39225] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39257] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39289] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_END_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39321] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39353] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39385] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + anon_sym_END_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39417] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39449] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39481] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39513] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39545] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39577] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39609] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39641] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39673] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39705] = 4, + ACTIONS(2370), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39739] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39771] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39803] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39835] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39867] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39899] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39931] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39963] = 4, + ACTIONS(2373), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [39997] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40029] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40061] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40093] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40125] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40157] = 4, + ACTIONS(2376), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40191] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40223] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40255] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40287] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40319] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40351] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40383] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40415] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40447] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40479] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40511] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40543] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40575] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40607] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40639] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40671] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_END_ORGANIZATION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40703] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40735] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40767] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40799] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40831] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2215), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2217), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40863] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40895] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40927] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40959] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [40991] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41023] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41055] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41087] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41119] = 4, + ACTIONS(2379), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41153] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41185] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41217] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41249] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41281] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41313] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41345] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41377] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41409] = 4, + ACTIONS(2382), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41443] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41475] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41507] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41539] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2077), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2079), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41571] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41603] = 4, + ACTIONS(2385), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2089), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2091), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41637] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41669] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2146), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2148), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41701] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2150), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2152), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41733] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2193), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2195), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41765] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2231), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2233), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41797] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2281), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2283), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41829] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1999), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2001), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41861] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41893] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2045), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41925] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2130), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2133), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41957] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2136), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2139), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [41989] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2183), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2186), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42021] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2197), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2200), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42053] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42085] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42117] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2229), 18, + anon_sym_END_FUNCTION_BLOCK, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42149] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2251), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2254), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42181] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42213] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42245] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42277] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2257), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2260), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42309] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2275), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2278), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42341] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1962), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1965), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42373] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2083), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2081), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42405] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42437] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42469] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42501] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2051), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2054), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42533] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2065), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2068), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42565] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2071), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2074), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42597] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2095), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2093), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42629] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2122), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2124), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42661] = 4, + ACTIONS(2388), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2168), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2170), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42695] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2175), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2177), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42727] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2189), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2191), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42759] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1360), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1362), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42791] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42823] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2102), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2100), 18, + anon_sym_END_FUNCTION, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42855] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2285), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2287), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42887] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42919] = 4, + ACTIONS(2391), 1, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1976), 3, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1978), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42953] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1983), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1985), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [42985] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1991), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1993), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [43017] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1995), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1997), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_REPEAT, + anon_sym_UNTIL, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [43049] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1968), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(1970), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [43081] = 3, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2207), 4, + anon_sym_SEMI, + anon_sym_POUND, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + ACTIONS(2209), 18, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + anon_sym_IF, + anon_sym_CASE, + anon_sym_FOR, + anon_sym_WHILE, + anon_sym_END_WHILE, + anon_sym_REPEAT, + anon_sym_REGION, + sym_identifier, + sym_exit_statement, + sym_continue_statement, + [43113] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1032), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43170] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1066), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43227] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(341), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43284] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(334), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43341] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(335), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43398] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(375), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43455] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(342), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43512] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(968), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43569] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(969), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43626] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(970), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43683] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(971), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43740] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(972), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43797] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(973), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43854] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(974), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43911] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(975), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [43968] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(976), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44025] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(977), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44082] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(978), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44139] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(980), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44196] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(983), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44253] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(984), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44310] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(986), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44367] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(998), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44424] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(988), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44481] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(989), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44538] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(992), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44595] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(994), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44652] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(995), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44709] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(997), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44766] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(999), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44823] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1000), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44880] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1001), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44937] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1004), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [44994] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1005), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45051] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1006), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45108] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1008), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45165] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1009), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45222] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1010), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45279] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1014), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45336] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1015), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45393] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1017), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45450] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1018), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45507] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1019), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45564] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1020), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45621] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(960), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45678] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1021), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45735] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1022), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45792] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1023), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45849] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1024), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45906] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1071), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [45963] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1069), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46020] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(951), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46077] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1027), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46134] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1028), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46191] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1029), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46248] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1030), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46305] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1011), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46362] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(964), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46419] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1031), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46476] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1068), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46533] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1034), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46590] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(956), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46647] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1035), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46704] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1036), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46761] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1037), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46818] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1038), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46875] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1072), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46932] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(950), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [46989] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(966), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47046] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1040), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47103] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1041), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47160] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1042), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47217] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(949), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47274] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1043), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47331] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(959), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47388] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1044), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47445] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1045), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47502] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1046), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47559] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1047), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47616] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(982), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47673] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1016), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47730] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(953), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47787] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1049), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47844] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1050), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47901] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1051), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [47958] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1052), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48015] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1073), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48072] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(963), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48129] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(958), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48186] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1053), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48243] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1054), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48300] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1055), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48357] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1056), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48414] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1070), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48471] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(965), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48528] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1058), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48585] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1059), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48642] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1060), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48699] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1061), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48756] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(339), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48813] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(967), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48870] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(952), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48927] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1062), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [48984] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1063), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49041] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1064), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49098] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1065), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49155] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(306), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49212] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(328), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49269] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(957), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49326] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1067), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49383] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1075), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49440] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1076), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49497] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1077), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49554] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1078), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49611] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1079), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49668] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1080), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49725] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1081), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49782] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1082), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49839] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1083), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49896] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1084), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [49953] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1085), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [50010] = 16, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(2396), 1, + anon_sym_LPAREN, + ACTIONS(2398), 1, + anon_sym_NOT, + ACTIONS(2400), 1, + sym_number, + ACTIONS(2404), 1, + sym_identifier, + STATE(245), 1, + sym_string, + STATE(1033), 1, + sym_expression, + STATE(1554), 1, + sym_function_name, + STATE(1577), 1, + sym_lvalue, + ACTIONS(2394), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2402), 2, + sym_hex_number, + sym_time_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + STATE(251), 3, + sym_prefixed_identifier, + sym_field_access, + sym_array_access, + STATE(307), 3, + sym_function_call, + sym_unary_expression, + sym_binary_expression, + [50067] = 15, + ACTIONS(2406), 1, + anon_sym_TITLE, + ACTIONS(2408), 1, + anon_sym_VERSION, + ACTIONS(2410), 1, + anon_sym_COLON, + ACTIONS(2412), 1, + anon_sym_BEGIN, + ACTIONS(2414), 1, + anon_sym_LBRACE, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2428), 1, + sym_block_comment, + STATE(962), 1, + sym_attribute_list, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1007), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50121] = 14, + ACTIONS(2414), 1, + anon_sym_LBRACE, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2430), 1, + anon_sym_TITLE, + ACTIONS(2432), 1, + anon_sym_VERSION, + ACTIONS(2434), 1, + anon_sym_BEGIN, + ACTIONS(2436), 1, + sym_block_comment, + STATE(961), 1, + sym_attribute_list, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1057), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50172] = 13, + ACTIONS(2414), 1, + anon_sym_LBRACE, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2438), 1, + anon_sym_VERSION, + ACTIONS(2440), 1, + anon_sym_BEGIN, + ACTIONS(2442), 1, + sym_block_comment, + STATE(954), 1, + sym_attribute_list, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1074), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50220] = 13, + ACTIONS(2414), 1, + anon_sym_LBRACE, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2444), 1, + anon_sym_VERSION, + ACTIONS(2446), 1, + anon_sym_BEGIN, + ACTIONS(2448), 1, + sym_block_comment, + STATE(955), 1, + sym_attribute_list, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(996), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50268] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2154), 1, + anon_sym_EQ, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2158), 1, + anon_sym_LT_GT, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2450), 3, + anon_sym_COMMA, + anon_sym_EQ_GT, + anon_sym_RPAREN, + [50313] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2454), 1, + anon_sym_BY, + ACTIONS(2456), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50357] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2458), 1, + anon_sym_BY, + ACTIONS(2460), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50401] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2462), 1, + anon_sym_BY, + ACTIONS(2464), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50445] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2466), 1, + anon_sym_BY, + ACTIONS(2468), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50489] = 11, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2470), 1, + anon_sym_VERSION, + ACTIONS(2472), 1, + anon_sym_BEGIN, + ACTIONS(2474), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(979), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50531] = 11, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2476), 1, + anon_sym_VERSION, + ACTIONS(2478), 1, + anon_sym_BEGIN, + ACTIONS(2480), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1002), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50573] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2482), 1, + anon_sym_BY, + ACTIONS(2484), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50617] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2486), 1, + anon_sym_BY, + ACTIONS(2488), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50661] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2490), 1, + anon_sym_BY, + ACTIONS(2492), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50705] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2494), 1, + anon_sym_BY, + ACTIONS(2496), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50749] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2498), 1, + anon_sym_BY, + ACTIONS(2500), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50793] = 11, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2438), 1, + anon_sym_VERSION, + ACTIONS(2440), 1, + anon_sym_BEGIN, + ACTIONS(2442), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1074), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50835] = 11, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2502), 1, + anon_sym_VERSION, + ACTIONS(2504), 1, + anon_sym_BEGIN, + ACTIONS(2506), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(990), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [50877] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2508), 1, + anon_sym_BY, + ACTIONS(2510), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50921] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2512), 1, + anon_sym_BY, + ACTIONS(2514), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [50965] = 12, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2516), 1, + anon_sym_BY, + ACTIONS(2518), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51009] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2520), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51050] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2522), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51091] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2524), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51132] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2526), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51173] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2528), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51214] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2530), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51255] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2532), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51296] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2534), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51337] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2536), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51378] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2538), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51419] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2540), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51460] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2542), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51501] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2544), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51542] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2446), 1, + anon_sym_BEGIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [51581] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2548), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51622] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2446), 1, + anon_sym_BEGIN, + ACTIONS(2448), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(996), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [51661] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2550), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51702] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2552), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51743] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2554), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51784] = 9, + ACTIONS(2556), 1, + anon_sym_TITLE, + ACTIONS(2558), 1, + anon_sym_VERSION, + ACTIONS(2560), 1, + anon_sym_BEGIN, + ACTIONS(2562), 1, + anon_sym_LBRACE, + ACTIONS(2566), 1, + anon_sym_VAR, + STATE(1093), 1, + sym_attribute_list, + STATE(1099), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [51821] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2568), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51862] = 9, + ACTIONS(2562), 1, + anon_sym_LBRACE, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2570), 1, + anon_sym_TITLE, + ACTIONS(2572), 1, + anon_sym_VERSION, + ACTIONS(2574), 1, + anon_sym_BEGIN, + STATE(1094), 1, + sym_attribute_list, + STATE(1113), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [51899] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2576), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51940] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2578), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [51981] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2434), 1, + anon_sym_BEGIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52020] = 10, + ACTIONS(2580), 1, + anon_sym_BEGIN, + ACTIONS(2585), 1, + anon_sym_VAR, + ACTIONS(2588), 1, + anon_sym_VAR_TEMP, + ACTIONS(2591), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2594), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2597), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2600), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2582), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52059] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2603), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52100] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2478), 1, + anon_sym_BEGIN, + ACTIONS(2480), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1002), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52139] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2605), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52180] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2607), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52221] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2478), 1, + anon_sym_BEGIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52260] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2609), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52301] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2611), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52342] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2613), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52383] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2615), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52424] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2617), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52465] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(2619), 1, + anon_sym_BEGIN, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52504] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2619), 1, + anon_sym_BEGIN, + ACTIONS(2621), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1012), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52543] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2623), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52584] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2625), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52625] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2627), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52666] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2504), 1, + anon_sym_BEGIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52705] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2629), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52746] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2631), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52787] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2633), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52828] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2635), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52869] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(2637), 1, + anon_sym_BEGIN, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52908] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2637), 1, + anon_sym_BEGIN, + ACTIONS(2639), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1025), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [52947] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2641), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [52988] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2643), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53029] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2645), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53070] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2647), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53111] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2649), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53152] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2651), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53193] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2653), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53234] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2655), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53275] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2657), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53316] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2659), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53357] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2661), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53398] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(2663), 1, + anon_sym_BEGIN, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [53437] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2663), 1, + anon_sym_BEGIN, + ACTIONS(2665), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1039), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [53476] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2667), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53517] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2669), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53558] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2671), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53599] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2673), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53640] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2675), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53681] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2677), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53722] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2679), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53763] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2681), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53804] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2683), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53845] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2685), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53886] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2687), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53927] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2689), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [53968] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(2691), 1, + anon_sym_BEGIN, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [54007] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2693), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54048] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2695), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54089] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2697), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54130] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2699), 1, + anon_sym_RPAREN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54171] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2701), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54212] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2703), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54253] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2705), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54294] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2707), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54335] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2440), 1, + anon_sym_BEGIN, + ACTIONS(2442), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(1074), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [54374] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2709), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54415] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2711), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54456] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2713), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54497] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2715), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54538] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2717), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54579] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2719), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54620] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2721), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54661] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2723), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54702] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2440), 1, + anon_sym_BEGIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [54741] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2725), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54782] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2727), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54823] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2729), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54864] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2731), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54905] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2733), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54946] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2735), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [54987] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2737), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55028] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2739), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55069] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2741), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55110] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2743), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55151] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2745), 1, + anon_sym_END_REPEAT, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55192] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2747), 1, + anon_sym_THEN, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55233] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2749), 1, + anon_sym_OF, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55274] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2751), 1, + anon_sym_DO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55315] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2753), 1, + anon_sym_SEMI, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55356] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2755), 1, + anon_sym_RBRACK, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55397] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2472), 1, + anon_sym_BEGIN, + ACTIONS(2546), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(991), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [55436] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2757), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55477] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2759), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55518] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2761), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55559] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2763), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55600] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2765), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55641] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2767), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55682] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2769), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55723] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2771), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55764] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2773), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55805] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2775), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55846] = 11, + ACTIONS(2112), 1, + anon_sym_SLASH, + ACTIONS(2156), 1, + anon_sym_AND, + ACTIONS(2293), 1, + anon_sym_XOR, + ACTIONS(2452), 1, + anon_sym_OR, + ACTIONS(2777), 1, + anon_sym_TO, + ACTIONS(2114), 2, + anon_sym_DASH, + anon_sym_PLUS, + ACTIONS(2116), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(2118), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(2120), 2, + anon_sym_STAR, + anon_sym_MOD, + ACTIONS(2158), 2, + anon_sym_EQ, + anon_sym_LT_GT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [55887] = 10, + ACTIONS(2418), 1, + anon_sym_VAR, + ACTIONS(2420), 1, + anon_sym_VAR_TEMP, + ACTIONS(2422), 1, + anon_sym_VAR_CONSTANT, + ACTIONS(2424), 1, + anon_sym_VAR_RETAIN, + ACTIONS(2426), 1, + anon_sym_VAR_NON_RETAIN, + ACTIONS(2472), 1, + anon_sym_BEGIN, + ACTIONS(2474), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2416), 3, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + STATE(979), 6, + sym_var_declaration, + sym_var_temp_declaration, + sym_var_constant_declaration, + sym_var_retain_declaration, + sym_var_non_retain_declaration, + aux_sym_function_repeat1, + [55926] = 8, + ACTIONS(2562), 1, + anon_sym_LBRACE, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2779), 1, + anon_sym_VERSION, + ACTIONS(2781), 1, + anon_sym_BEGIN, + STATE(1096), 1, + sym_attribute_list, + STATE(1115), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [55960] = 8, + ACTIONS(2562), 1, + anon_sym_LBRACE, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2783), 1, + anon_sym_VERSION, + ACTIONS(2785), 1, + anon_sym_BEGIN, + STATE(1097), 1, + sym_attribute_list, + STATE(1119), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [55994] = 4, + ACTIONS(2789), 1, + anon_sym_VAR, + ACTIONS(2791), 1, + anon_sym_LBRACK, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2787), 12, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [56019] = 3, + ACTIONS(1358), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(1356), 13, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_COLON, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [56042] = 3, + ACTIONS(1354), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(1352), 13, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_COLON, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [56065] = 3, + ACTIONS(2795), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2793), 12, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [56087] = 6, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2797), 1, + anon_sym_VERSION, + ACTIONS(2799), 1, + anon_sym_BEGIN, + STATE(1111), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56115] = 6, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2801), 1, + anon_sym_VERSION, + ACTIONS(2803), 1, + anon_sym_BEGIN, + STATE(1108), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56143] = 3, + ACTIONS(2789), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2787), 12, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [56165] = 6, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2805), 1, + anon_sym_VERSION, + ACTIONS(2807), 1, + anon_sym_BEGIN, + STATE(1112), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56193] = 6, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2809), 1, + anon_sym_VERSION, + ACTIONS(2811), 1, + anon_sym_BEGIN, + STATE(1101), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56221] = 3, + ACTIONS(2815), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2813), 12, + anon_sym_TITLE, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_LBRACE, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [56243] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2799), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56268] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2785), 1, + anon_sym_BEGIN, + STATE(1119), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56293] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2817), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56318] = 5, + ACTIONS(2819), 1, + anon_sym_BEGIN, + ACTIONS(2824), 1, + anon_sym_VAR, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2821), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56343] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2827), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56368] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2829), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56393] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2829), 1, + anon_sym_BEGIN, + STATE(1122), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56418] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2831), 1, + anon_sym_BEGIN, + STATE(1107), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56443] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2833), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56468] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2835), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56493] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2833), 1, + anon_sym_BEGIN, + STATE(1103), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56518] = 3, + ACTIONS(2839), 1, + anon_sym_VAR, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2837), 10, + anon_sym_VERSION, + anon_sym_COLON, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56539] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2841), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56564] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2843), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56589] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2803), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56614] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2781), 1, + anon_sym_BEGIN, + STATE(1115), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56639] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2807), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56664] = 3, + ACTIONS(2847), 1, + anon_sym_VAR, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2845), 10, + anon_sym_VERSION, + anon_sym_COLON, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56685] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2807), 1, + anon_sym_BEGIN, + STATE(1112), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56710] = 3, + ACTIONS(2851), 1, + anon_sym_VAR, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2849), 10, + anon_sym_VERSION, + anon_sym_COLON, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56731] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2811), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56756] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2811), 1, + anon_sym_BEGIN, + STATE(1101), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56781] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2853), 1, + anon_sym_BEGIN, + STATE(1104), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56806] = 5, + ACTIONS(2566), 1, + anon_sym_VAR, + ACTIONS(2855), 1, + anon_sym_BEGIN, + STATE(1102), 2, + sym_var_declaration, + aux_sym_organization_block_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2564), 7, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [56831] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2859), 1, + anon_sym_END_CASE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + STATE(1637), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [56863] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2865), 1, + anon_sym_END_CASE, + STATE(1598), 1, + sym_else_clause, + STATE(1134), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [56895] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2867), 1, + anon_sym_END_CASE, + STATE(1662), 1, + sym_else_clause, + STATE(1127), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [56927] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2869), 1, + anon_sym_END_CASE, + STATE(1686), 1, + sym_else_clause, + STATE(1136), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [56959] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2871), 1, + anon_sym_END_CASE, + STATE(1729), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [56991] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2873), 1, + anon_sym_END_CASE, + STATE(1725), 1, + sym_else_clause, + STATE(1130), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57023] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2875), 1, + anon_sym_END_CASE, + STATE(1718), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57055] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2877), 1, + anon_sym_END_CASE, + STATE(1735), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57087] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2879), 1, + anon_sym_END_CASE, + STATE(1627), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57119] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2881), 1, + anon_sym_END_CASE, + STATE(1618), 1, + sym_else_clause, + STATE(1142), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57151] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2883), 1, + anon_sym_END_CASE, + STATE(1680), 1, + sym_else_clause, + STATE(1149), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57183] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2885), 1, + anon_sym_END_CASE, + STATE(1625), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57215] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2887), 1, + anon_sym_END_CASE, + STATE(1614), 1, + sym_else_clause, + STATE(1123), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57247] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2889), 1, + anon_sym_END_CASE, + STATE(1704), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57279] = 3, + ACTIONS(2851), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2849), 10, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57299] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2891), 1, + anon_sym_END_CASE, + STATE(1623), 1, + sym_else_clause, + STATE(1143), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57331] = 3, + ACTIONS(2847), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2845), 10, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57351] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2893), 1, + anon_sym_END_CASE, + STATE(1724), 1, + sym_else_clause, + STATE(1147), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57383] = 3, + ACTIONS(2839), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2837), 10, + anon_sym_VERSION, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57403] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2895), 1, + anon_sym_END_CASE, + STATE(1657), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57435] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2897), 1, + anon_sym_END_CASE, + STATE(1639), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57467] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2899), 1, + anon_sym_END_CASE, + STATE(1723), 1, + sym_else_clause, + STATE(1129), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57499] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2901), 1, + anon_sym_END_CASE, + STATE(1722), 1, + sym_else_clause, + STATE(1131), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57531] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2903), 1, + anon_sym_END_CASE, + STATE(1612), 1, + sym_else_clause, + STATE(1148), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57563] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2905), 1, + anon_sym_END_CASE, + STATE(1653), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57595] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2907), 1, + anon_sym_END_CASE, + STATE(1626), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57627] = 9, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(2857), 1, + anon_sym_ELSE, + ACTIONS(2861), 1, + sym_number, + ACTIONS(2863), 1, + sym_identifier, + ACTIONS(2909), 1, + anon_sym_END_CASE, + STATE(1690), 1, + sym_else_clause, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57659] = 3, + ACTIONS(2229), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2227), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57678] = 3, + ACTIONS(2200), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2197), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57697] = 3, + ACTIONS(2186), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2183), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57716] = 3, + ACTIONS(2133), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2130), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57735] = 3, + ACTIONS(2913), 1, + anon_sym_VAR, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2911), 8, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [57754] = 3, + ACTIONS(2229), 1, + anon_sym_VAR, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2227), 8, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [57773] = 3, + ACTIONS(2045), 1, + anon_sym_VAR, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2043), 8, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + [57792] = 3, + ACTIONS(2139), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2136), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57811] = 3, + ACTIONS(2254), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2251), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57830] = 3, + ACTIONS(2260), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2257), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57849] = 3, + ACTIONS(2278), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2275), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57868] = 3, + ACTIONS(1965), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(1962), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57887] = 3, + ACTIONS(2045), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2043), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57906] = 3, + ACTIONS(2074), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2071), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57925] = 3, + ACTIONS(2068), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2065), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57944] = 3, + ACTIONS(2054), 1, + anon_sym_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(2051), 9, + anon_sym_BEGIN, + anon_sym_VAR_INPUT, + anon_sym_VAR_OUTPUT, + anon_sym_VAR_IN_OUT, + anon_sym_VAR_TEMP, + anon_sym_VAR_CONSTANT, + anon_sym_VAR_RETAIN, + anon_sym_VAR_NON_RETAIN, + sym_block_comment, + [57963] = 7, + ACTIONS(2915), 1, + anon_sym_POUND, + ACTIONS(2920), 1, + sym_number, + ACTIONS(2923), 1, + sym_identifier, + ACTIONS(2918), 2, + anon_sym_ELSE, + anon_sym_END_CASE, + STATE(1166), 2, + sym_case_item, + aux_sym_case_statement_repeat1, + STATE(1610), 2, + sym_prefixed_identifier, + sym_range, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [57990] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(187), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58016] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(102), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58042] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(148), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58068] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(129), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58094] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(158), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58120] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(172), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58146] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(178), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58172] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(196), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58198] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(121), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58224] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(112), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58250] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(138), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58276] = 7, + ACTIONS(1693), 1, + anon_sym_SLASH, + ACTIONS(2926), 1, + anon_sym_SQUOTE, + ACTIONS(2928), 1, + anon_sym_DQUOTE, + STATE(168), 1, + sym_region_name, + ACTIONS(1695), 2, + anon_sym_DASH, + sym_identifier, + STATE(273), 2, + sym_string, + aux_sym_region_name_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58302] = 8, + ACTIONS(2930), 1, + anon_sym_CONSTANT, + ACTIONS(2932), 1, + anon_sym_RETAIN, + ACTIONS(2934), 1, + anon_sym_NON_RETAIN, + ACTIONS(2936), 1, + anon_sym_END_VAR, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2940), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1528), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58329] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2942), 1, + anon_sym_CONSTANT, + ACTIONS(2944), 1, + anon_sym_RETAIN, + ACTIONS(2946), 1, + anon_sym_NON_RETAIN, + ACTIONS(2948), 1, + anon_sym_END_VAR, + ACTIONS(2950), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1309), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58356] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2952), 1, + anon_sym_CONSTANT, + ACTIONS(2954), 1, + anon_sym_RETAIN, + ACTIONS(2956), 1, + anon_sym_NON_RETAIN, + ACTIONS(2958), 1, + anon_sym_END_VAR, + ACTIONS(2960), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1370), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58383] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2962), 1, + anon_sym_CONSTANT, + ACTIONS(2964), 1, + anon_sym_RETAIN, + ACTIONS(2966), 1, + anon_sym_NON_RETAIN, + ACTIONS(2968), 1, + anon_sym_END_VAR, + ACTIONS(2970), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1228), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58410] = 6, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + STATE(1558), 1, + sym_string, + STATE(1559), 1, + sym_attribute_value, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(2972), 3, + anon_sym_TRUE, + anon_sym_FALSE, + sym_identifier, + [58433] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2974), 1, + anon_sym_CONSTANT, + ACTIONS(2976), 1, + anon_sym_RETAIN, + ACTIONS(2978), 1, + anon_sym_NON_RETAIN, + ACTIONS(2980), 1, + anon_sym_END_VAR, + ACTIONS(2982), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1317), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58460] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2984), 1, + anon_sym_CONSTANT, + ACTIONS(2986), 1, + anon_sym_RETAIN, + ACTIONS(2988), 1, + anon_sym_NON_RETAIN, + ACTIONS(2990), 1, + anon_sym_END_VAR, + ACTIONS(2992), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1454), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58487] = 6, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2996), 1, + anon_sym_END_VAR, + ACTIONS(2998), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1432), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + ACTIONS(2994), 3, + anon_sym_CONSTANT, + anon_sym_RETAIN, + anon_sym_NON_RETAIN, + [58510] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3000), 1, + anon_sym_CONSTANT, + ACTIONS(3002), 1, + anon_sym_RETAIN, + ACTIONS(3004), 1, + anon_sym_NON_RETAIN, + ACTIONS(3006), 1, + anon_sym_END_VAR, + ACTIONS(3008), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1273), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58537] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3010), 1, + anon_sym_CONSTANT, + ACTIONS(3012), 1, + anon_sym_RETAIN, + ACTIONS(3014), 1, + anon_sym_NON_RETAIN, + ACTIONS(3016), 1, + anon_sym_END_VAR, + ACTIONS(3018), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1292), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58564] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3020), 1, + anon_sym_CONSTANT, + ACTIONS(3022), 1, + anon_sym_RETAIN, + ACTIONS(3024), 1, + anon_sym_NON_RETAIN, + ACTIONS(3026), 1, + anon_sym_END_VAR, + ACTIONS(3028), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1342), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58591] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3030), 1, + anon_sym_CONSTANT, + ACTIONS(3032), 1, + anon_sym_RETAIN, + ACTIONS(3034), 1, + anon_sym_NON_RETAIN, + ACTIONS(3036), 1, + anon_sym_END_VAR, + ACTIONS(3038), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1394), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58618] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3040), 1, + anon_sym_CONSTANT, + ACTIONS(3042), 1, + anon_sym_RETAIN, + ACTIONS(3044), 1, + anon_sym_NON_RETAIN, + ACTIONS(3046), 1, + anon_sym_END_VAR, + ACTIONS(3048), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1503), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58645] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3050), 1, + anon_sym_CONSTANT, + ACTIONS(3052), 1, + anon_sym_RETAIN, + ACTIONS(3054), 1, + anon_sym_NON_RETAIN, + ACTIONS(3056), 1, + anon_sym_END_VAR, + ACTIONS(3058), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1257), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58672] = 8, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3060), 1, + anon_sym_CONSTANT, + ACTIONS(3062), 1, + anon_sym_RETAIN, + ACTIONS(3064), 1, + anon_sym_NON_RETAIN, + ACTIONS(3066), 1, + anon_sym_END_VAR, + ACTIONS(3068), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1377), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [58699] = 6, + ACTIONS(3070), 1, + anon_sym_END_IF, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + STATE(1733), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58721] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3076), 1, + anon_sym_END_IF, + STATE(1684), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58743] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3078), 1, + anon_sym_END_IF, + STATE(1674), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58765] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3080), 1, + anon_sym_END_IF, + STATE(1689), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58787] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3082), 1, + anon_sym_END_IF, + STATE(1630), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58809] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3084), 1, + anon_sym_END_IF, + STATE(1671), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58831] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3086), 1, + anon_sym_END_IF, + STATE(1646), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58853] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3088), 1, + anon_sym_END_IF, + STATE(1601), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58875] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3090), 1, + anon_sym_END_IF, + STATE(1631), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58897] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3092), 1, + anon_sym_END_IF, + STATE(1596), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58919] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3094), 1, + anon_sym_END_IF, + STATE(1696), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58941] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3096), 1, + anon_sym_END_IF, + STATE(1682), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58963] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3098), 1, + anon_sym_END_IF, + STATE(1702), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [58985] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3100), 1, + anon_sym_END_IF, + STATE(1622), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59007] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3102), 1, + anon_sym_END_IF, + STATE(1642), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59029] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3104), 1, + anon_sym_END_IF, + STATE(1613), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59051] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3106), 1, + anon_sym_END_IF, + STATE(1711), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59073] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3108), 1, + anon_sym_END_IF, + STATE(1716), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59095] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3110), 1, + anon_sym_END_IF, + STATE(1620), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59117] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3112), 1, + anon_sym_END_IF, + STATE(1687), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59139] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3114), 1, + anon_sym_END_IF, + STATE(1634), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59161] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3116), 1, + anon_sym_END_IF, + STATE(1633), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59183] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3118), 1, + anon_sym_END_IF, + STATE(1737), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59205] = 6, + ACTIONS(3072), 1, + anon_sym_ELSIF, + ACTIONS(3074), 1, + anon_sym_ELSE, + ACTIONS(3120), 1, + anon_sym_END_IF, + STATE(1628), 1, + sym_else_clause, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59227] = 4, + ACTIONS(3124), 1, + anon_sym_ELSIF, + ACTIONS(3122), 2, + anon_sym_END_IF, + anon_sym_ELSE, + STATE(1218), 2, + sym_elsif_clause, + aux_sym_if_statement_repeat1, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59244] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3127), 1, + anon_sym_END_VAR, + ACTIONS(3129), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1300), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59262] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3131), 1, + anon_sym_END_VAR, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59280] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2968), 1, + anon_sym_END_VAR, + ACTIONS(2970), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1228), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59298] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3135), 1, + anon_sym_END_VAR, + ACTIONS(3137), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1232), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59316] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3139), 1, + anon_sym_END_VAR, + ACTIONS(3141), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1233), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59334] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3143), 1, + anon_sym_END_VAR, + ACTIONS(3145), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1234), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59352] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3147), 1, + anon_sym_END_VAR, + ACTIONS(3149), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1235), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59370] = 4, + ACTIONS(3151), 1, + anon_sym_SQUOTE, + STATE(1237), 1, + aux_sym_string_repeat1, + ACTIONS(3153), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59386] = 4, + ACTIONS(3151), 1, + anon_sym_DQUOTE, + STATE(1238), 1, + aux_sym_string_repeat2, + ACTIONS(3157), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59402] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3159), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59420] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3161), 1, + anon_sym_END_VAR, + ACTIONS(3163), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1240), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59438] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3165), 1, + anon_sym_END_VAR, + ACTIONS(3167), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1241), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59456] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3169), 1, + anon_sym_END_VAR, + ACTIONS(3171), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1242), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59474] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3173), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59492] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3161), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59510] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3165), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59528] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3169), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59546] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3175), 1, + anon_sym_END_VAR, + ACTIONS(3177), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1437), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59564] = 4, + ACTIONS(3179), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59580] = 4, + ACTIONS(3179), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59596] = 5, + ACTIONS(3185), 1, + anon_sym_RPAREN, + ACTIONS(3187), 1, + sym_identifier, + STATE(1515), 1, + sym_parameter, + STATE(1583), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59614] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3189), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59632] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3191), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59650] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3193), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59668] = 4, + ACTIONS(3197), 1, + anon_sym_RBRACE, + STATE(1496), 1, + aux_sym_attribute_list_repeat1, + ACTIONS(3195), 2, + anon_sym_COMMA, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59684] = 5, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(3199), 1, + sym_identifier, + STATE(1088), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59702] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3006), 1, + anon_sym_END_VAR, + ACTIONS(3008), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1273), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59720] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3201), 1, + anon_sym_END_VAR, + ACTIONS(3203), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1278), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59738] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3205), 1, + anon_sym_END_VAR, + ACTIONS(3207), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1279), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59756] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3209), 1, + anon_sym_END_VAR, + ACTIONS(3211), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1280), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59774] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3056), 1, + anon_sym_END_VAR, + ACTIONS(3058), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1257), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59792] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3213), 1, + anon_sym_END_VAR, + ACTIONS(3215), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1281), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59810] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3217), 1, + anon_sym_END_VAR, + ACTIONS(3219), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1261), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59828] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3221), 1, + anon_sym_END_VAR, + ACTIONS(3223), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1262), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59846] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3225), 1, + anon_sym_END_VAR, + ACTIONS(3227), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1263), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59864] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3229), 1, + anon_sym_END_VAR, + ACTIONS(3231), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1264), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59882] = 4, + ACTIONS(3233), 1, + anon_sym_SQUOTE, + STATE(1266), 1, + aux_sym_string_repeat1, + ACTIONS(3235), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59898] = 4, + ACTIONS(3233), 1, + anon_sym_DQUOTE, + STATE(1267), 1, + aux_sym_string_repeat2, + ACTIONS(3237), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [59914] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3239), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59932] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3241), 1, + anon_sym_END_VAR, + ACTIONS(3243), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1269), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59950] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3245), 1, + anon_sym_END_VAR, + ACTIONS(3247), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1270), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59968] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3249), 1, + anon_sym_END_VAR, + ACTIONS(3251), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1271), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [59986] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3253), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60004] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3241), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60022] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3245), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60040] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3249), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60058] = 4, + ACTIONS(3255), 1, + anon_sym_SQUOTE, + STATE(1282), 1, + aux_sym_string_repeat1, + ACTIONS(3257), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60074] = 4, + ACTIONS(3259), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60090] = 4, + ACTIONS(3259), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60106] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3261), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1580), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60124] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3263), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60142] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3265), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60160] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3267), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60178] = 4, + ACTIONS(3255), 1, + anon_sym_DQUOTE, + STATE(1283), 1, + aux_sym_string_repeat2, + ACTIONS(3269), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60194] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3271), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60212] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3273), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1569), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60230] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3275), 1, + anon_sym_END_VAR, + ACTIONS(3277), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1307), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60248] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3279), 1, + anon_sym_END_VAR, + ACTIONS(3281), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1444), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60266] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3283), 1, + anon_sym_END_VAR, + ACTIONS(3285), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1308), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60284] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3287), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60302] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3127), 1, + anon_sym_END_VAR, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60320] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3275), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60338] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3283), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60356] = 4, + ACTIONS(3289), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60372] = 4, + ACTIONS(3289), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60388] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3016), 1, + anon_sym_END_VAR, + ACTIONS(3018), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1292), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60406] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3291), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1588), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60424] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3293), 1, + anon_sym_END_VAR, + ACTIONS(3295), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1296), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60442] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3297), 1, + anon_sym_END_VAR, + ACTIONS(3299), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1297), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60460] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3301), 1, + anon_sym_END_VAR, + ACTIONS(3303), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1298), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60478] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3305), 1, + anon_sym_END_VAR, + ACTIONS(3307), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1299), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60496] = 4, + ACTIONS(3309), 1, + anon_sym_SQUOTE, + STATE(1301), 1, + aux_sym_string_repeat1, + ACTIONS(3311), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60512] = 4, + ACTIONS(3309), 1, + anon_sym_DQUOTE, + STATE(1302), 1, + aux_sym_string_repeat2, + ACTIONS(3313), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60528] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3315), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60546] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3317), 1, + anon_sym_END_VAR, + ACTIONS(3319), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1304), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60564] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3321), 1, + anon_sym_END_VAR, + ACTIONS(3323), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1305), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60582] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3325), 1, + anon_sym_END_VAR, + ACTIONS(3327), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1306), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60600] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3329), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60618] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3317), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60636] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3321), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60654] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3325), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60672] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3331), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60690] = 4, + ACTIONS(3333), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60706] = 4, + ACTIONS(3333), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60722] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3335), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1586), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60740] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3337), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60758] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3339), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60776] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3341), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60794] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3343), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60812] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3345), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60830] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3347), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60848] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2980), 1, + anon_sym_END_VAR, + ACTIONS(2982), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1317), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60866] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3349), 1, + anon_sym_END_VAR, + ACTIONS(3351), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1321), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60884] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3353), 1, + anon_sym_END_VAR, + ACTIONS(3355), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1322), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60902] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3357), 1, + anon_sym_END_VAR, + ACTIONS(3359), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1323), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60920] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3361), 1, + anon_sym_END_VAR, + ACTIONS(3363), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1324), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60938] = 4, + ACTIONS(3365), 1, + anon_sym_SQUOTE, + STATE(1326), 1, + aux_sym_string_repeat1, + ACTIONS(3367), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60954] = 4, + ACTIONS(3365), 1, + anon_sym_DQUOTE, + STATE(1327), 1, + aux_sym_string_repeat2, + ACTIONS(3369), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [60970] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3371), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [60988] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3373), 1, + anon_sym_END_VAR, + ACTIONS(3375), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1329), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61006] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3377), 1, + anon_sym_END_VAR, + ACTIONS(3379), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1330), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61024] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3381), 1, + anon_sym_END_VAR, + ACTIONS(3383), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1331), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61042] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3385), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61060] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3373), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61078] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3377), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61096] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3381), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61114] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3387), 1, + anon_sym_END_VAR, + ACTIONS(3389), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1368), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61132] = 4, + ACTIONS(3391), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61148] = 4, + ACTIONS(3391), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61164] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3393), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1572), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61182] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3395), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61200] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3397), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61218] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3399), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61236] = 4, + ACTIONS(3401), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61252] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3403), 1, + anon_sym_END_VAR, + ACTIONS(3405), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1405), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61270] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3026), 1, + anon_sym_END_VAR, + ACTIONS(3028), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1342), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61288] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3407), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1589), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61306] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3409), 1, + anon_sym_END_VAR, + ACTIONS(3411), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1346), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61324] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3413), 1, + anon_sym_END_VAR, + ACTIONS(3415), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1347), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61342] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3417), 1, + anon_sym_END_VAR, + ACTIONS(3419), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1348), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61360] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3421), 1, + anon_sym_END_VAR, + ACTIONS(3423), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1349), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61378] = 4, + ACTIONS(3425), 1, + anon_sym_SQUOTE, + STATE(1351), 1, + aux_sym_string_repeat1, + ACTIONS(3427), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61394] = 4, + ACTIONS(3425), 1, + anon_sym_DQUOTE, + STATE(1352), 1, + aux_sym_string_repeat2, + ACTIONS(3429), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61410] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3431), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61428] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3433), 1, + anon_sym_END_VAR, + ACTIONS(3435), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1354), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61446] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3437), 1, + anon_sym_END_VAR, + ACTIONS(3439), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1355), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61464] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3441), 1, + anon_sym_END_VAR, + ACTIONS(3443), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1356), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61482] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3445), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61500] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3433), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61518] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3437), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61536] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3441), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61554] = 4, + ACTIONS(3449), 1, + anon_sym_RBRACE, + STATE(1430), 1, + aux_sym_attribute_list_repeat1, + ACTIONS(3447), 2, + anon_sym_COMMA, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61570] = 4, + ACTIONS(3451), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61586] = 4, + ACTIONS(3451), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61602] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3453), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1590), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61620] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3455), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61638] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3457), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61656] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3459), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61674] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2958), 1, + anon_sym_END_VAR, + ACTIONS(2960), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1370), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61692] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2996), 1, + anon_sym_END_VAR, + ACTIONS(2998), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1432), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61710] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3461), 1, + anon_sym_END_VAR, + ACTIONS(3463), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1402), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61728] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3465), 1, + anon_sym_END_VAR, + ACTIONS(3467), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1423), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61746] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3469), 1, + anon_sym_END_VAR, + ACTIONS(3471), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1406), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61764] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3473), 1, + anon_sym_END_VAR, + ACTIONS(3475), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1407), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61782] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3477), 1, + anon_sym_END_VAR, + ACTIONS(3479), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1410), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61800] = 4, + ACTIONS(3481), 1, + anon_sym_SQUOTE, + STATE(1411), 1, + aux_sym_string_repeat1, + ACTIONS(3483), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61816] = 4, + ACTIONS(3481), 1, + anon_sym_DQUOTE, + STATE(1412), 1, + aux_sym_string_repeat2, + ACTIONS(3485), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [61832] = 5, + ACTIONS(3487), 1, + anon_sym_END_VAR, + ACTIONS(3489), 1, + sym_identifier, + ACTIONS(3492), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61850] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3495), 1, + anon_sym_END_VAR, + ACTIONS(3497), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1452), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61868] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3499), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61886] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3066), 1, + anon_sym_END_VAR, + ACTIONS(3068), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1377), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61904] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3501), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61922] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3503), 1, + anon_sym_END_VAR, + ACTIONS(3505), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1381), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61940] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3507), 1, + anon_sym_END_VAR, + ACTIONS(3509), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1382), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61958] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3511), 1, + anon_sym_END_VAR, + ACTIONS(3513), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1383), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61976] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3515), 1, + anon_sym_END_VAR, + ACTIONS(3517), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1384), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [61994] = 4, + ACTIONS(3519), 1, + anon_sym_SQUOTE, + STATE(1385), 1, + aux_sym_string_repeat1, + ACTIONS(3521), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62010] = 4, + ACTIONS(3519), 1, + anon_sym_DQUOTE, + STATE(1386), 1, + aux_sym_string_repeat2, + ACTIONS(3523), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62026] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3525), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62044] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3527), 1, + anon_sym_END_VAR, + ACTIONS(3529), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1388), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62062] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3531), 1, + anon_sym_END_VAR, + ACTIONS(3533), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1389), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62080] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3535), 1, + anon_sym_END_VAR, + ACTIONS(3537), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1390), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62098] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3539), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62116] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3527), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62134] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3531), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62152] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3535), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62170] = 4, + ACTIONS(3541), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62186] = 4, + ACTIONS(3541), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62202] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3543), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1571), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62220] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3545), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62238] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3547), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62256] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3549), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62274] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3036), 1, + anon_sym_END_VAR, + ACTIONS(3038), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1394), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62292] = 4, + ACTIONS(3551), 1, + anon_sym_SQUOTE, + STATE(1395), 1, + aux_sym_string_repeat1, + ACTIONS(3553), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62308] = 4, + ACTIONS(3551), 1, + anon_sym_DQUOTE, + STATE(1396), 1, + aux_sym_string_repeat2, + ACTIONS(3555), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62324] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3557), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62342] = 4, + ACTIONS(3559), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62358] = 4, + ACTIONS(3559), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62374] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3561), 1, + anon_sym_END_VAR, + ACTIONS(3563), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1414), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62392] = 3, + ACTIONS(3565), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62406] = 3, + ACTIONS(3565), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62420] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3567), 1, + anon_sym_END_VAR, + ACTIONS(3569), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1415), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62438] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3571), 1, + anon_sym_END_VAR, + ACTIONS(3573), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1416), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62456] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3575), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62474] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3577), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62492] = 4, + ACTIONS(3579), 1, + anon_sym_COMMA, + STATE(1491), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(3581), 2, + anon_sym_EQ_GT, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62508] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3583), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62526] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3561), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62544] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3567), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62562] = 4, + ACTIONS(3585), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62578] = 3, + ACTIONS(3587), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62592] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3571), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62610] = 4, + ACTIONS(3589), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62626] = 4, + ACTIONS(3589), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62642] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3591), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1587), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62660] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3593), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62678] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3595), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62696] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3597), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62714] = 3, + ACTIONS(3599), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62728] = 3, + ACTIONS(3599), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62742] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3601), 1, + anon_sym_END_VAR, + ACTIONS(3603), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1403), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62760] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3605), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62778] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3607), 1, + anon_sym_END_VAR, + ACTIONS(3609), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1443), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62796] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3611), 1, + anon_sym_END_VAR, + ACTIONS(3613), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1466), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62814] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3615), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62832] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3617), 1, + anon_sym_END_VAR, + ACTIONS(3619), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1476), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62850] = 3, + ACTIONS(3621), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62864] = 3, + ACTIONS(3621), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [62878] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3623), 1, + anon_sym_END_VAR, + ACTIONS(3625), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1477), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62896] = 4, + ACTIONS(3627), 1, + anon_sym_SQUOTE, + STATE(1480), 1, + aux_sym_string_repeat1, + ACTIONS(3629), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62912] = 4, + ACTIONS(3627), 1, + anon_sym_DQUOTE, + STATE(1483), 1, + aux_sym_string_repeat2, + ACTIONS(3631), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62928] = 4, + ACTIONS(3635), 1, + anon_sym_RBRACE, + STATE(1496), 1, + aux_sym_attribute_list_repeat1, + ACTIONS(3633), 2, + anon_sym_COMMA, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [62944] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3637), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62962] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3639), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62980] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3641), 1, + anon_sym_END_VAR, + ACTIONS(3643), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1485), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [62998] = 3, + ACTIONS(3645), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63012] = 3, + ACTIONS(3645), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63026] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3647), 1, + anon_sym_END_VAR, + ACTIONS(3649), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1486), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63044] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3387), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63062] = 3, + ACTIONS(3651), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63076] = 3, + ACTIONS(3651), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63090] = 5, + ACTIONS(61), 1, + anon_sym_SQUOTE, + ACTIONS(63), 1, + anon_sym_DQUOTE, + ACTIONS(3653), 1, + sym_identifier, + STATE(947), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63108] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3655), 1, + anon_sym_END_VAR, + ACTIONS(3657), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1487), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63126] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2990), 1, + anon_sym_END_VAR, + ACTIONS(2992), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1454), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63144] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3659), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63162] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3403), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63180] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3661), 1, + anon_sym_END_VAR, + ACTIONS(3663), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1460), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63198] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3665), 1, + anon_sym_END_VAR, + ACTIONS(3667), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1461), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63216] = 3, + ACTIONS(3669), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63230] = 3, + ACTIONS(3669), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63244] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3671), 1, + anon_sym_END_VAR, + ACTIONS(3673), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1462), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63262] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3675), 1, + anon_sym_END_VAR, + ACTIONS(3677), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1465), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63280] = 4, + ACTIONS(3679), 1, + anon_sym_SQUOTE, + STATE(1467), 1, + aux_sym_string_repeat1, + ACTIONS(3681), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63296] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3465), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63314] = 4, + ACTIONS(3679), 1, + anon_sym_DQUOTE, + STATE(1468), 1, + aux_sym_string_repeat2, + ACTIONS(3683), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63330] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3685), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63348] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3687), 1, + anon_sym_END_VAR, + ACTIONS(3689), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1471), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63366] = 3, + ACTIONS(3691), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63380] = 3, + ACTIONS(3691), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63394] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3693), 1, + anon_sym_END_VAR, + ACTIONS(3695), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1472), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63412] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3697), 1, + anon_sym_END_VAR, + ACTIONS(3699), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1475), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63430] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3701), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63448] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3687), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63466] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3693), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63484] = 3, + ACTIONS(3703), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63498] = 3, + ACTIONS(3703), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63512] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3697), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63530] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3641), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63548] = 4, + ACTIONS(3705), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63564] = 4, + ACTIONS(3705), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63580] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3707), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1574), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63598] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2948), 1, + anon_sym_END_VAR, + ACTIONS(2950), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1309), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63616] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3709), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63634] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3711), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63652] = 3, + ACTIONS(3713), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63666] = 3, + ACTIONS(3713), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63680] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3715), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63698] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3647), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63716] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3655), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63734] = 4, + ACTIONS(3717), 1, + anon_sym_SQUOTE, + STATE(1493), 1, + aux_sym_string_repeat1, + ACTIONS(3719), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63750] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3639), 1, + anon_sym_END_VAR, + ACTIONS(3721), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1431), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63768] = 4, + ACTIONS(3723), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63784] = 3, + ACTIONS(3725), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63798] = 3, + ACTIONS(3725), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63812] = 4, + ACTIONS(3723), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63828] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3727), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1591), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63846] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3729), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63864] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3731), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63882] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3733), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [63900] = 4, + ACTIONS(3717), 1, + anon_sym_DQUOTE, + STATE(1332), 1, + aux_sym_string_repeat2, + ACTIONS(3735), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63916] = 3, + ACTIONS(3737), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [63930] = 4, + ACTIONS(3741), 1, + anon_sym_RBRACE, + STATE(1243), 1, + aux_sym_attribute_list_repeat1, + ACTIONS(3739), 2, + anon_sym_COMMA, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63946] = 4, + ACTIONS(3743), 1, + anon_sym_COMMA, + STATE(1491), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(3746), 2, + anon_sym_EQ_GT, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63962] = 4, + ACTIONS(3748), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3750), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63978] = 4, + ACTIONS(3401), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [63994] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3046), 1, + anon_sym_END_VAR, + ACTIONS(3048), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1503), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64012] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3753), 1, + anon_sym_END_VAR, + ACTIONS(3755), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1507), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64030] = 4, + ACTIONS(3760), 1, + anon_sym_RBRACE, + STATE(1496), 1, + aux_sym_attribute_list_repeat1, + ACTIONS(3757), 2, + anon_sym_COMMA, + anon_sym_SEMI, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64046] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3762), 1, + anon_sym_END_VAR, + ACTIONS(3764), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1508), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64064] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3766), 1, + anon_sym_END_VAR, + ACTIONS(3768), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1509), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64082] = 4, + ACTIONS(3770), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3772), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64098] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3775), 1, + anon_sym_END_VAR, + ACTIONS(3777), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1510), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64116] = 4, + ACTIONS(3779), 1, + anon_sym_SQUOTE, + STATE(1511), 1, + aux_sym_string_repeat1, + ACTIONS(3781), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64132] = 4, + ACTIONS(3779), 1, + anon_sym_DQUOTE, + STATE(1512), 1, + aux_sym_string_repeat2, + ACTIONS(3783), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64148] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3785), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64166] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3787), 1, + anon_sym_END_VAR, + ACTIONS(3789), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1514), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64184] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3791), 1, + anon_sym_END_VAR, + ACTIONS(3793), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1516), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64202] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3795), 1, + anon_sym_END_VAR, + ACTIONS(3797), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1517), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64220] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3799), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64238] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3787), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64256] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3791), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64274] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3795), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64292] = 4, + ACTIONS(3801), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64308] = 4, + ACTIONS(3801), 1, + anon_sym_DQUOTE, + STATE(1499), 1, + aux_sym_string_repeat2, + ACTIONS(3183), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64324] = 5, + ACTIONS(3187), 1, + sym_identifier, + ACTIONS(3803), 1, + anon_sym_RPAREN, + STATE(1515), 1, + sym_parameter, + STATE(1592), 1, + sym_parameter_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64342] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3805), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64360] = 4, + ACTIONS(3579), 1, + anon_sym_COMMA, + STATE(1404), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(3807), 2, + anon_sym_EQ_GT, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64376] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3809), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64394] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3811), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64412] = 5, + ACTIONS(61), 1, + anon_sym_SQUOTE, + ACTIONS(63), 1, + anon_sym_DQUOTE, + ACTIONS(3813), 1, + sym_identifier, + STATE(948), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64430] = 5, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + ACTIONS(3815), 1, + sym_identifier, + STATE(1087), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64448] = 5, + ACTIONS(2936), 1, + anon_sym_END_VAR, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(2940), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1528), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64466] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3817), 1, + anon_sym_END_VAR, + ACTIONS(3819), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1532), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64484] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3821), 1, + anon_sym_END_VAR, + ACTIONS(3823), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1533), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64502] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3825), 1, + anon_sym_END_VAR, + ACTIONS(3827), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1534), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64520] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3829), 1, + anon_sym_END_VAR, + ACTIONS(3831), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1535), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64538] = 4, + ACTIONS(3833), 1, + anon_sym_SQUOTE, + STATE(1537), 1, + aux_sym_string_repeat1, + ACTIONS(3835), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64554] = 4, + ACTIONS(3833), 1, + anon_sym_DQUOTE, + STATE(1408), 1, + aux_sym_string_repeat2, + ACTIONS(3837), 2, + aux_sym_string_token2, + anon_sym_DQUOTE_DQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64570] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3839), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64588] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3841), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64606] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3843), 1, + anon_sym_END_VAR, + ACTIONS(3845), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1220), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64624] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3847), 1, + anon_sym_END_VAR, + ACTIONS(3849), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1527), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64642] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3851), 1, + anon_sym_END_VAR, + ACTIONS(3853), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1420), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64660] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3855), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64678] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3843), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64696] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3847), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64714] = 5, + ACTIONS(2938), 1, + sym_identifier, + ACTIONS(3133), 1, + sym_block_comment, + ACTIONS(3851), 1, + anon_sym_END_VAR, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + STATE(1366), 2, + sym_var_item, + aux_sym_var_declaration_repeat1, + [64732] = 3, + ACTIONS(3737), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1517), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [64746] = 4, + ACTIONS(3585), 1, + anon_sym_SQUOTE, + STATE(1492), 1, + aux_sym_string_repeat1, + ACTIONS(3181), 2, + aux_sym_string_token1, + anon_sym_SQUOTE_SQUOTE, + ACTIONS(3155), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64762] = 3, + ACTIONS(3587), 1, + anon_sym_LPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [64776] = 4, + ACTIONS(3857), 1, + anon_sym_COLON_EQ, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64791] = 4, + ACTIONS(3197), 1, + anon_sym_RBRACE, + ACTIONS(3863), 1, + sym_identifier, + STATE(1562), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64806] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3865), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64821] = 4, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + STATE(985), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64836] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3867), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64851] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3869), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64866] = 4, + ACTIONS(61), 1, + anon_sym_SQUOTE, + ACTIONS(63), 1, + anon_sym_DQUOTE, + STATE(945), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64881] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3871), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64896] = 4, + ACTIONS(27), 1, + anon_sym_POUND, + ACTIONS(3873), 1, + sym_identifier, + STATE(247), 1, + sym_prefixed_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64911] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3875), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64926] = 2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(3746), 3, + anon_sym_COMMA, + anon_sym_EQ_GT, + anon_sym_RPAREN, + [64937] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3877), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64952] = 4, + ACTIONS(41), 1, + anon_sym_SQUOTE, + ACTIONS(43), 1, + anon_sym_DQUOTE, + STATE(987), 1, + sym_string, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64967] = 3, + ACTIONS(3879), 1, + anon_sym_LBRACK, + ACTIONS(2787), 2, + anon_sym_SEMI, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64980] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3881), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [64995] = 2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(1537), 3, + anon_sym_COLON_EQ, + anon_sym_LBRACK, + anon_sym_DOT, + [65006] = 4, + ACTIONS(3863), 1, + sym_identifier, + ACTIONS(3883), 1, + anon_sym_RBRACE, + STATE(1562), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65021] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3885), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65036] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3887), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65051] = 2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(3889), 3, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACE, + [65062] = 2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(3891), 3, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACE, + [65073] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3893), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65088] = 4, + ACTIONS(2562), 1, + anon_sym_LBRACE, + ACTIONS(3895), 1, + anon_sym_COLON, + STATE(1692), 1, + sym_attribute_list, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65103] = 2, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + ACTIONS(3760), 3, + anon_sym_COMMA, + anon_sym_SEMI, + anon_sym_RBRACE, + [65114] = 4, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3897), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65129] = 4, + ACTIONS(3863), 1, + sym_identifier, + ACTIONS(3899), 1, + anon_sym_RBRACE, + STATE(1562), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65144] = 4, + ACTIONS(3635), 1, + anon_sym_RBRACE, + ACTIONS(3863), 1, + sym_identifier, + STATE(1562), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65159] = 3, + ACTIONS(3901), 1, + anon_sym_SEMI, + ACTIONS(3903), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65171] = 3, + ACTIONS(3907), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(3905), 2, + anon_sym_END_VAR, + sym_identifier, + [65183] = 3, + ACTIONS(3911), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(3909), 2, + anon_sym_END_VAR, + sym_identifier, + [65195] = 3, + ACTIONS(3913), 1, + anon_sym_EQ_GT, + ACTIONS(3915), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65207] = 3, + ACTIONS(3917), 1, + anon_sym_COLON, + ACTIONS(3919), 1, + anon_sym_DOT_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65219] = 3, + ACTIONS(3921), 1, + anon_sym_EQ_GT, + ACTIONS(3923), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65231] = 3, + ACTIONS(3925), 1, + anon_sym_EQ_GT, + ACTIONS(3927), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65243] = 3, + ACTIONS(3931), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(3929), 2, + anon_sym_END_VAR, + sym_identifier, + [65255] = 3, + ACTIONS(3933), 1, + anon_sym_EQ_GT, + ACTIONS(3935), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65267] = 3, + ACTIONS(3937), 1, + anon_sym_SEMI, + ACTIONS(3939), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65279] = 2, + ACTIONS(2787), 2, + anon_sym_SEMI, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65289] = 3, + ACTIONS(3859), 1, + anon_sym_LBRACK, + ACTIONS(3861), 1, + anon_sym_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65301] = 3, + ACTIONS(3187), 1, + sym_identifier, + STATE(1549), 1, + sym_parameter, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65313] = 3, + ACTIONS(3863), 1, + sym_identifier, + STATE(1490), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65325] = 3, + ACTIONS(3941), 1, + anon_sym_EQ_GT, + ACTIONS(3943), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65337] = 2, + ACTIONS(2813), 2, + anon_sym_SEMI, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65347] = 3, + ACTIONS(3863), 1, + sym_identifier, + STATE(1350), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65359] = 3, + ACTIONS(3945), 1, + anon_sym_EQ_GT, + ACTIONS(3947), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65371] = 2, + ACTIONS(2793), 2, + anon_sym_SEMI, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65381] = 3, + ACTIONS(3863), 1, + sym_identifier, + STATE(1562), 1, + sym_attribute, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65393] = 3, + ACTIONS(3949), 1, + anon_sym_EQ_GT, + ACTIONS(3951), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65405] = 3, + ACTIONS(3953), 1, + anon_sym_EQ_GT, + ACTIONS(3955), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65417] = 3, + ACTIONS(3957), 1, + anon_sym_EQ_GT, + ACTIONS(3959), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65429] = 3, + ACTIONS(3961), 1, + anon_sym_EQ_GT, + ACTIONS(3963), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65441] = 3, + ACTIONS(3965), 1, + anon_sym_EQ_GT, + ACTIONS(3967), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65453] = 3, + ACTIONS(3969), 1, + anon_sym_EQ_GT, + ACTIONS(3971), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65465] = 3, + ACTIONS(3973), 1, + anon_sym_EQ_GT, + ACTIONS(3975), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65477] = 3, + ACTIONS(3979), 1, + sym_block_comment, + ACTIONS(3), 2, + sym_line_comment, + sym_c_style_comment, + ACTIONS(3977), 2, + anon_sym_END_VAR, + sym_identifier, + [65489] = 2, + ACTIONS(3981), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65498] = 2, + ACTIONS(3983), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65507] = 2, + ACTIONS(3985), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65516] = 2, + ACTIONS(3987), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65525] = 2, + ACTIONS(3989), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65534] = 2, + ACTIONS(3991), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65543] = 2, + ACTIONS(3993), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65552] = 2, + ACTIONS(3995), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65561] = 2, + ACTIONS(3997), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65570] = 2, + ACTIONS(3999), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65579] = 2, + ACTIONS(4001), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65588] = 2, + ACTIONS(4003), 1, + anon_sym_RBRACK, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65597] = 2, + ACTIONS(4005), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65606] = 2, + ACTIONS(3110), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65615] = 2, + ACTIONS(4007), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65624] = 2, + ACTIONS(4009), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65633] = 2, + ACTIONS(3917), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65642] = 2, + ACTIONS(4011), 1, + anon_sym_OF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65651] = 2, + ACTIONS(4013), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65660] = 2, + ACTIONS(3086), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65669] = 2, + ACTIONS(4015), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65678] = 2, + ACTIONS(4017), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65687] = 2, + ACTIONS(4019), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65696] = 2, + ACTIONS(3114), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65705] = 2, + ACTIONS(4021), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65714] = 2, + ACTIONS(4023), 1, + anon_sym_LBRACK, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65723] = 2, + ACTIONS(3116), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65732] = 2, + ACTIONS(4025), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65741] = 2, + ACTIONS(3084), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65750] = 2, + ACTIONS(4027), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65759] = 2, + ACTIONS(4029), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65768] = 2, + ACTIONS(4031), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65777] = 2, + ACTIONS(4033), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65786] = 2, + ACTIONS(4035), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65795] = 2, + ACTIONS(3092), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65804] = 2, + ACTIONS(4037), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65813] = 2, + ACTIONS(3080), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65822] = 2, + ACTIONS(3076), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65831] = 2, + ACTIONS(4039), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65840] = 2, + ACTIONS(4041), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65849] = 2, + ACTIONS(3102), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65858] = 2, + ACTIONS(4043), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65867] = 2, + ACTIONS(4045), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65876] = 2, + ACTIONS(4047), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65885] = 2, + ACTIONS(4049), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65894] = 2, + ACTIONS(4051), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65903] = 2, + ACTIONS(4053), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65912] = 2, + ACTIONS(4055), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65921] = 2, + ACTIONS(4057), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65930] = 2, + ACTIONS(4059), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65939] = 2, + ACTIONS(4061), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65948] = 2, + ACTIONS(4063), 1, + anon_sym_RBRACK, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65957] = 2, + ACTIONS(4065), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65966] = 2, + ACTIONS(4067), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65975] = 2, + ACTIONS(4069), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65984] = 2, + ACTIONS(4071), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [65993] = 2, + ACTIONS(4073), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66002] = 2, + ACTIONS(4075), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66011] = 2, + ACTIONS(4077), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66020] = 2, + ACTIONS(4079), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66029] = 2, + ACTIONS(4081), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66038] = 2, + ACTIONS(3108), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66047] = 2, + ACTIONS(3082), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66056] = 2, + ACTIONS(4083), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66065] = 2, + ACTIONS(4085), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66074] = 2, + ACTIONS(4087), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66083] = 2, + ACTIONS(4089), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66092] = 2, + ACTIONS(4091), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66101] = 2, + ACTIONS(4093), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66110] = 2, + ACTIONS(4095), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66119] = 2, + ACTIONS(4097), 1, + anon_sym_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66128] = 2, + ACTIONS(4099), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66137] = 2, + ACTIONS(4101), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66146] = 2, + ACTIONS(4103), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66155] = 2, + ACTIONS(4105), 1, + anon_sym_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66164] = 2, + ACTIONS(4107), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66173] = 2, + ACTIONS(4109), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66182] = 2, + ACTIONS(4111), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66191] = 2, + ACTIONS(3112), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66200] = 2, + ACTIONS(4113), 1, + anon_sym_OF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66209] = 2, + ACTIONS(3088), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66218] = 2, + ACTIONS(4115), 1, + ts_builtin_sym_end, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66227] = 2, + ACTIONS(4117), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66236] = 2, + ACTIONS(4119), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66245] = 2, + ACTIONS(4121), 1, + anon_sym_RBRACK, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66254] = 2, + ACTIONS(3098), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66263] = 2, + ACTIONS(4123), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66272] = 2, + ACTIONS(4125), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66281] = 2, + ACTIONS(4127), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66290] = 2, + ACTIONS(4129), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66299] = 2, + ACTIONS(4131), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66308] = 2, + ACTIONS(4133), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66317] = 2, + ACTIONS(4135), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66326] = 2, + ACTIONS(3094), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66335] = 2, + ACTIONS(3120), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66344] = 2, + ACTIONS(4137), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66353] = 2, + ACTIONS(4139), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66362] = 2, + ACTIONS(4141), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66371] = 2, + ACTIONS(4143), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66380] = 2, + ACTIONS(4145), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66389] = 2, + ACTIONS(4147), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66398] = 2, + ACTIONS(4149), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66407] = 2, + ACTIONS(4151), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66416] = 2, + ACTIONS(4153), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66425] = 2, + ACTIONS(4155), 1, + anon_sym_RBRACK, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66434] = 2, + ACTIONS(4157), 1, + anon_sym_DOT_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66443] = 2, + ACTIONS(4159), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66452] = 2, + ACTIONS(4161), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66461] = 2, + ACTIONS(3106), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66470] = 2, + ACTIONS(4163), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66479] = 2, + ACTIONS(4165), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66488] = 2, + ACTIONS(4167), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66497] = 2, + ACTIONS(4169), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66506] = 2, + ACTIONS(4171), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66515] = 2, + ACTIONS(4173), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66524] = 2, + ACTIONS(4175), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66533] = 2, + ACTIONS(3070), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66542] = 2, + ACTIONS(4177), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66551] = 2, + ACTIONS(4179), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66560] = 2, + ACTIONS(4181), 1, + anon_sym_COLON, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66569] = 2, + ACTIONS(4183), 1, + anon_sym_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66578] = 2, + ACTIONS(4185), 1, + anon_sym_DOT_DOT, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66587] = 2, + ACTIONS(3096), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66596] = 2, + ACTIONS(4187), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66605] = 2, + ACTIONS(4189), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66614] = 2, + ACTIONS(3100), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66623] = 2, + ACTIONS(3078), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66632] = 2, + ACTIONS(4191), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66641] = 2, + ACTIONS(4193), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66650] = 2, + ACTIONS(4195), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66659] = 2, + ACTIONS(4197), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66668] = 2, + ACTIONS(4199), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66677] = 2, + ACTIONS(3090), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66686] = 2, + ACTIONS(4201), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66695] = 2, + ACTIONS(4203), 1, + anon_sym_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66704] = 2, + ACTIONS(4205), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66713] = 2, + ACTIONS(3104), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66722] = 2, + ACTIONS(4207), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66731] = 2, + ACTIONS(4209), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66740] = 2, + ACTIONS(3118), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66749] = 2, + ACTIONS(4211), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66758] = 2, + ACTIONS(4213), 1, + anon_sym_END_CASE, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66767] = 2, + ACTIONS(4215), 1, + anon_sym_RPAREN, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66776] = 2, + ACTIONS(4217), 1, + anon_sym_END_IF, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66785] = 2, + ACTIONS(4219), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66794] = 2, + ACTIONS(4221), 1, + anon_sym_LBRACK, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66803] = 2, + ACTIONS(4223), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66812] = 2, + ACTIONS(4225), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66821] = 2, + ACTIONS(4227), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66830] = 2, + ACTIONS(4229), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66839] = 2, + ACTIONS(4231), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66848] = 2, + ACTIONS(4233), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66857] = 2, + ACTIONS(4235), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66866] = 2, + ACTIONS(4237), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66875] = 2, + ACTIONS(4239), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66884] = 2, + ACTIONS(4241), 1, + anon_sym_COLON_EQ, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66893] = 2, + ACTIONS(4243), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66902] = 2, + ACTIONS(4245), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66911] = 2, + ACTIONS(4247), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66920] = 2, + ACTIONS(4249), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66929] = 2, + ACTIONS(4251), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66938] = 2, + ACTIONS(4253), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66947] = 2, + ACTIONS(4255), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66956] = 2, + ACTIONS(4257), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66965] = 2, + ACTIONS(4259), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66974] = 2, + ACTIONS(4261), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66983] = 2, + ACTIONS(4263), 1, + sym_identifier, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, + [66992] = 2, + ACTIONS(4265), 1, + sym_number, + ACTIONS(3), 3, + sym_line_comment, + sym_block_comment, + sym_c_style_comment, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(2)] = 0, + [SMALL_STATE(3)] = 79, + [SMALL_STATE(4)] = 158, + [SMALL_STATE(5)] = 237, + [SMALL_STATE(6)] = 316, + [SMALL_STATE(7)] = 395, + [SMALL_STATE(8)] = 505, + [SMALL_STATE(9)] = 615, + [SMALL_STATE(10)] = 726, + [SMALL_STATE(11)] = 837, + [SMALL_STATE(12)] = 948, + [SMALL_STATE(13)] = 1059, + [SMALL_STATE(14)] = 1170, + [SMALL_STATE(15)] = 1281, + [SMALL_STATE(16)] = 1392, + [SMALL_STATE(17)] = 1503, + [SMALL_STATE(18)] = 1614, + [SMALL_STATE(19)] = 1725, + [SMALL_STATE(20)] = 1836, + [SMALL_STATE(21)] = 1947, + [SMALL_STATE(22)] = 2058, + [SMALL_STATE(23)] = 2169, + [SMALL_STATE(24)] = 2280, + [SMALL_STATE(25)] = 2391, + [SMALL_STATE(26)] = 2502, + [SMALL_STATE(27)] = 2613, + [SMALL_STATE(28)] = 2724, + [SMALL_STATE(29)] = 2835, + [SMALL_STATE(30)] = 2946, + [SMALL_STATE(31)] = 3057, + [SMALL_STATE(32)] = 3168, + [SMALL_STATE(33)] = 3279, + [SMALL_STATE(34)] = 3381, + [SMALL_STATE(35)] = 3481, + [SMALL_STATE(36)] = 3583, + [SMALL_STATE(37)] = 3683, + [SMALL_STATE(38)] = 3783, + [SMALL_STATE(39)] = 3885, + [SMALL_STATE(40)] = 3983, + [SMALL_STATE(41)] = 4081, + [SMALL_STATE(42)] = 4179, + [SMALL_STATE(43)] = 4277, + [SMALL_STATE(44)] = 4375, + [SMALL_STATE(45)] = 4473, + [SMALL_STATE(46)] = 4571, + [SMALL_STATE(47)] = 4669, + [SMALL_STATE(48)] = 4767, + [SMALL_STATE(49)] = 4865, + [SMALL_STATE(50)] = 4963, + [SMALL_STATE(51)] = 5061, + [SMALL_STATE(52)] = 5159, + [SMALL_STATE(53)] = 5257, + [SMALL_STATE(54)] = 5355, + [SMALL_STATE(55)] = 5453, + [SMALL_STATE(56)] = 5551, + [SMALL_STATE(57)] = 5649, + [SMALL_STATE(58)] = 5747, + [SMALL_STATE(59)] = 5845, + [SMALL_STATE(60)] = 5943, + [SMALL_STATE(61)] = 6041, + [SMALL_STATE(62)] = 6139, + [SMALL_STATE(63)] = 6237, + [SMALL_STATE(64)] = 6335, + [SMALL_STATE(65)] = 6433, + [SMALL_STATE(66)] = 6531, + [SMALL_STATE(67)] = 6629, + [SMALL_STATE(68)] = 6727, + [SMALL_STATE(69)] = 6825, + [SMALL_STATE(70)] = 6923, + [SMALL_STATE(71)] = 7021, + [SMALL_STATE(72)] = 7119, + [SMALL_STATE(73)] = 7217, + [SMALL_STATE(74)] = 7315, + [SMALL_STATE(75)] = 7413, + [SMALL_STATE(76)] = 7511, + [SMALL_STATE(77)] = 7609, + [SMALL_STATE(78)] = 7707, + [SMALL_STATE(79)] = 7805, + [SMALL_STATE(80)] = 7903, + [SMALL_STATE(81)] = 8001, + [SMALL_STATE(82)] = 8099, + [SMALL_STATE(83)] = 8197, + [SMALL_STATE(84)] = 8295, + [SMALL_STATE(85)] = 8393, + [SMALL_STATE(86)] = 8491, + [SMALL_STATE(87)] = 8589, + [SMALL_STATE(88)] = 8687, + [SMALL_STATE(89)] = 8785, + [SMALL_STATE(90)] = 8883, + [SMALL_STATE(91)] = 8981, + [SMALL_STATE(92)] = 9079, + [SMALL_STATE(93)] = 9177, + [SMALL_STATE(94)] = 9275, + [SMALL_STATE(95)] = 9373, + [SMALL_STATE(96)] = 9471, + [SMALL_STATE(97)] = 9569, + [SMALL_STATE(98)] = 9667, + [SMALL_STATE(99)] = 9765, + [SMALL_STATE(100)] = 9863, + [SMALL_STATE(101)] = 9961, + [SMALL_STATE(102)] = 10059, + [SMALL_STATE(103)] = 10157, + [SMALL_STATE(104)] = 10255, + [SMALL_STATE(105)] = 10353, + [SMALL_STATE(106)] = 10451, + [SMALL_STATE(107)] = 10549, + [SMALL_STATE(108)] = 10647, + [SMALL_STATE(109)] = 10745, + [SMALL_STATE(110)] = 10843, + [SMALL_STATE(111)] = 10941, + [SMALL_STATE(112)] = 11039, + [SMALL_STATE(113)] = 11137, + [SMALL_STATE(114)] = 11235, + [SMALL_STATE(115)] = 11333, + [SMALL_STATE(116)] = 11431, + [SMALL_STATE(117)] = 11529, + [SMALL_STATE(118)] = 11627, + [SMALL_STATE(119)] = 11725, + [SMALL_STATE(120)] = 11823, + [SMALL_STATE(121)] = 11921, + [SMALL_STATE(122)] = 12019, + [SMALL_STATE(123)] = 12117, + [SMALL_STATE(124)] = 12215, + [SMALL_STATE(125)] = 12313, + [SMALL_STATE(126)] = 12411, + [SMALL_STATE(127)] = 12509, + [SMALL_STATE(128)] = 12607, + [SMALL_STATE(129)] = 12705, + [SMALL_STATE(130)] = 12803, + [SMALL_STATE(131)] = 12901, + [SMALL_STATE(132)] = 12999, + [SMALL_STATE(133)] = 13097, + [SMALL_STATE(134)] = 13195, + [SMALL_STATE(135)] = 13293, + [SMALL_STATE(136)] = 13391, + [SMALL_STATE(137)] = 13489, + [SMALL_STATE(138)] = 13587, + [SMALL_STATE(139)] = 13685, + [SMALL_STATE(140)] = 13783, + [SMALL_STATE(141)] = 13881, + [SMALL_STATE(142)] = 13979, + [SMALL_STATE(143)] = 14077, + [SMALL_STATE(144)] = 14175, + [SMALL_STATE(145)] = 14273, + [SMALL_STATE(146)] = 14371, + [SMALL_STATE(147)] = 14469, + [SMALL_STATE(148)] = 14567, + [SMALL_STATE(149)] = 14665, + [SMALL_STATE(150)] = 14763, + [SMALL_STATE(151)] = 14861, + [SMALL_STATE(152)] = 14959, + [SMALL_STATE(153)] = 15057, + [SMALL_STATE(154)] = 15155, + [SMALL_STATE(155)] = 15253, + [SMALL_STATE(156)] = 15351, + [SMALL_STATE(157)] = 15449, + [SMALL_STATE(158)] = 15547, + [SMALL_STATE(159)] = 15645, + [SMALL_STATE(160)] = 15743, + [SMALL_STATE(161)] = 15841, + [SMALL_STATE(162)] = 15939, + [SMALL_STATE(163)] = 16037, + [SMALL_STATE(164)] = 16135, + [SMALL_STATE(165)] = 16233, + [SMALL_STATE(166)] = 16331, + [SMALL_STATE(167)] = 16429, + [SMALL_STATE(168)] = 16527, + [SMALL_STATE(169)] = 16625, + [SMALL_STATE(170)] = 16723, + [SMALL_STATE(171)] = 16821, + [SMALL_STATE(172)] = 16919, + [SMALL_STATE(173)] = 17017, + [SMALL_STATE(174)] = 17115, + [SMALL_STATE(175)] = 17213, + [SMALL_STATE(176)] = 17311, + [SMALL_STATE(177)] = 17409, + [SMALL_STATE(178)] = 17507, + [SMALL_STATE(179)] = 17605, + [SMALL_STATE(180)] = 17703, + [SMALL_STATE(181)] = 17801, + [SMALL_STATE(182)] = 17899, + [SMALL_STATE(183)] = 17997, + [SMALL_STATE(184)] = 18095, + [SMALL_STATE(185)] = 18193, + [SMALL_STATE(186)] = 18291, + [SMALL_STATE(187)] = 18389, + [SMALL_STATE(188)] = 18487, + [SMALL_STATE(189)] = 18585, + [SMALL_STATE(190)] = 18683, + [SMALL_STATE(191)] = 18781, + [SMALL_STATE(192)] = 18879, + [SMALL_STATE(193)] = 18977, + [SMALL_STATE(194)] = 19075, + [SMALL_STATE(195)] = 19173, + [SMALL_STATE(196)] = 19271, + [SMALL_STATE(197)] = 19369, + [SMALL_STATE(198)] = 19467, + [SMALL_STATE(199)] = 19565, + [SMALL_STATE(200)] = 19663, + [SMALL_STATE(201)] = 19761, + [SMALL_STATE(202)] = 19859, + [SMALL_STATE(203)] = 19957, + [SMALL_STATE(204)] = 20055, + [SMALL_STATE(205)] = 20153, + [SMALL_STATE(206)] = 20251, + [SMALL_STATE(207)] = 20349, + [SMALL_STATE(208)] = 20447, + [SMALL_STATE(209)] = 20545, + [SMALL_STATE(210)] = 20643, + [SMALL_STATE(211)] = 20741, + [SMALL_STATE(212)] = 20839, + [SMALL_STATE(213)] = 20937, + [SMALL_STATE(214)] = 21035, + [SMALL_STATE(215)] = 21133, + [SMALL_STATE(216)] = 21231, + [SMALL_STATE(217)] = 21329, + [SMALL_STATE(218)] = 21427, + [SMALL_STATE(219)] = 21525, + [SMALL_STATE(220)] = 21623, + [SMALL_STATE(221)] = 21721, + [SMALL_STATE(222)] = 21819, + [SMALL_STATE(223)] = 21917, + [SMALL_STATE(224)] = 22015, + [SMALL_STATE(225)] = 22113, + [SMALL_STATE(226)] = 22211, + [SMALL_STATE(227)] = 22309, + [SMALL_STATE(228)] = 22407, + [SMALL_STATE(229)] = 22505, + [SMALL_STATE(230)] = 22603, + [SMALL_STATE(231)] = 22655, + [SMALL_STATE(232)] = 22707, + [SMALL_STATE(233)] = 22761, + [SMALL_STATE(234)] = 22815, + [SMALL_STATE(235)] = 22864, + [SMALL_STATE(236)] = 22917, + [SMALL_STATE(237)] = 22956, + [SMALL_STATE(238)] = 23009, + [SMALL_STATE(239)] = 23062, + [SMALL_STATE(240)] = 23115, + [SMALL_STATE(241)] = 23166, + [SMALL_STATE(242)] = 23214, + [SMALL_STATE(243)] = 23264, + [SMALL_STATE(244)] = 23314, + [SMALL_STATE(245)] = 23352, + [SMALL_STATE(246)] = 23394, + [SMALL_STATE(247)] = 23442, + [SMALL_STATE(248)] = 23480, + [SMALL_STATE(249)] = 23522, + [SMALL_STATE(250)] = 23573, + [SMALL_STATE(251)] = 23624, + [SMALL_STATE(252)] = 23663, + [SMALL_STATE(253)] = 23714, + [SMALL_STATE(254)] = 23765, + [SMALL_STATE(255)] = 23816, + [SMALL_STATE(256)] = 23867, + [SMALL_STATE(257)] = 23918, + [SMALL_STATE(258)] = 23969, + [SMALL_STATE(259)] = 24020, + [SMALL_STATE(260)] = 24071, + [SMALL_STATE(261)] = 24122, + [SMALL_STATE(262)] = 24173, + [SMALL_STATE(263)] = 24224, + [SMALL_STATE(264)] = 24275, + [SMALL_STATE(265)] = 24326, + [SMALL_STATE(266)] = 24377, + [SMALL_STATE(267)] = 24414, + [SMALL_STATE(268)] = 24465, + [SMALL_STATE(269)] = 24516, + [SMALL_STATE(270)] = 24553, + [SMALL_STATE(271)] = 24589, + [SMALL_STATE(272)] = 24637, + [SMALL_STATE(273)] = 24673, + [SMALL_STATE(274)] = 24721, + [SMALL_STATE(275)] = 24767, + [SMALL_STATE(276)] = 24815, + [SMALL_STATE(277)] = 24861, + [SMALL_STATE(278)] = 24907, + [SMALL_STATE(279)] = 24943, + [SMALL_STATE(280)] = 24991, + [SMALL_STATE(281)] = 25027, + [SMALL_STATE(282)] = 25075, + [SMALL_STATE(283)] = 25123, + [SMALL_STATE(284)] = 25169, + [SMALL_STATE(285)] = 25215, + [SMALL_STATE(286)] = 25263, + [SMALL_STATE(287)] = 25311, + [SMALL_STATE(288)] = 25357, + [SMALL_STATE(289)] = 25403, + [SMALL_STATE(290)] = 25449, + [SMALL_STATE(291)] = 25495, + [SMALL_STATE(292)] = 25543, + [SMALL_STATE(293)] = 25578, + [SMALL_STATE(294)] = 25613, + [SMALL_STATE(295)] = 25648, + [SMALL_STATE(296)] = 25685, + [SMALL_STATE(297)] = 25720, + [SMALL_STATE(298)] = 25755, + [SMALL_STATE(299)] = 25790, + [SMALL_STATE(300)] = 25825, + [SMALL_STATE(301)] = 25860, + [SMALL_STATE(302)] = 25895, + [SMALL_STATE(303)] = 25930, + [SMALL_STATE(304)] = 25965, + [SMALL_STATE(305)] = 26000, + [SMALL_STATE(306)] = 26035, + [SMALL_STATE(307)] = 26070, + [SMALL_STATE(308)] = 26105, + [SMALL_STATE(309)] = 26140, + [SMALL_STATE(310)] = 26175, + [SMALL_STATE(311)] = 26210, + [SMALL_STATE(312)] = 26245, + [SMALL_STATE(313)] = 26280, + [SMALL_STATE(314)] = 26315, + [SMALL_STATE(315)] = 26350, + [SMALL_STATE(316)] = 26385, + [SMALL_STATE(317)] = 26420, + [SMALL_STATE(318)] = 26455, + [SMALL_STATE(319)] = 26490, + [SMALL_STATE(320)] = 26525, + [SMALL_STATE(321)] = 26560, + [SMALL_STATE(322)] = 26595, + [SMALL_STATE(323)] = 26630, + [SMALL_STATE(324)] = 26665, + [SMALL_STATE(325)] = 26702, + [SMALL_STATE(326)] = 26737, + [SMALL_STATE(327)] = 26772, + [SMALL_STATE(328)] = 26807, + [SMALL_STATE(329)] = 26852, + [SMALL_STATE(330)] = 26887, + [SMALL_STATE(331)] = 26922, + [SMALL_STATE(332)] = 26957, + [SMALL_STATE(333)] = 26992, + [SMALL_STATE(334)] = 27027, + [SMALL_STATE(335)] = 27062, + [SMALL_STATE(336)] = 27101, + [SMALL_STATE(337)] = 27136, + [SMALL_STATE(338)] = 27171, + [SMALL_STATE(339)] = 27206, + [SMALL_STATE(340)] = 27255, + [SMALL_STATE(341)] = 27290, + [SMALL_STATE(342)] = 27337, + [SMALL_STATE(343)] = 27378, + [SMALL_STATE(344)] = 27413, + [SMALL_STATE(345)] = 27450, + [SMALL_STATE(346)] = 27485, + [SMALL_STATE(347)] = 27520, + [SMALL_STATE(348)] = 27555, + [SMALL_STATE(349)] = 27590, + [SMALL_STATE(350)] = 27625, + [SMALL_STATE(351)] = 27660, + [SMALL_STATE(352)] = 27695, + [SMALL_STATE(353)] = 27730, + [SMALL_STATE(354)] = 27765, + [SMALL_STATE(355)] = 27800, + [SMALL_STATE(356)] = 27835, + [SMALL_STATE(357)] = 27870, + [SMALL_STATE(358)] = 27905, + [SMALL_STATE(359)] = 27940, + [SMALL_STATE(360)] = 27975, + [SMALL_STATE(361)] = 28010, + [SMALL_STATE(362)] = 28045, + [SMALL_STATE(363)] = 28080, + [SMALL_STATE(364)] = 28115, + [SMALL_STATE(365)] = 28150, + [SMALL_STATE(366)] = 28185, + [SMALL_STATE(367)] = 28220, + [SMALL_STATE(368)] = 28255, + [SMALL_STATE(369)] = 28290, + [SMALL_STATE(370)] = 28325, + [SMALL_STATE(371)] = 28360, + [SMALL_STATE(372)] = 28395, + [SMALL_STATE(373)] = 28430, + [SMALL_STATE(374)] = 28465, + [SMALL_STATE(375)] = 28500, + [SMALL_STATE(376)] = 28551, + [SMALL_STATE(377)] = 28585, + [SMALL_STATE(378)] = 28619, + [SMALL_STATE(379)] = 28653, + [SMALL_STATE(380)] = 28687, + [SMALL_STATE(381)] = 28721, + [SMALL_STATE(382)] = 28755, + [SMALL_STATE(383)] = 28791, + [SMALL_STATE(384)] = 28825, + [SMALL_STATE(385)] = 28859, + [SMALL_STATE(386)] = 28893, + [SMALL_STATE(387)] = 28927, + [SMALL_STATE(388)] = 28961, + [SMALL_STATE(389)] = 28995, + [SMALL_STATE(390)] = 29029, + [SMALL_STATE(391)] = 29063, + [SMALL_STATE(392)] = 29097, + [SMALL_STATE(393)] = 29131, + [SMALL_STATE(394)] = 29165, + [SMALL_STATE(395)] = 29199, + [SMALL_STATE(396)] = 29233, + [SMALL_STATE(397)] = 29267, + [SMALL_STATE(398)] = 29301, + [SMALL_STATE(399)] = 29335, + [SMALL_STATE(400)] = 29369, + [SMALL_STATE(401)] = 29403, + [SMALL_STATE(402)] = 29437, + [SMALL_STATE(403)] = 29473, + [SMALL_STATE(404)] = 29507, + [SMALL_STATE(405)] = 29541, + [SMALL_STATE(406)] = 29575, + [SMALL_STATE(407)] = 29609, + [SMALL_STATE(408)] = 29643, + [SMALL_STATE(409)] = 29677, + [SMALL_STATE(410)] = 29711, + [SMALL_STATE(411)] = 29747, + [SMALL_STATE(412)] = 29781, + [SMALL_STATE(413)] = 29815, + [SMALL_STATE(414)] = 29849, + [SMALL_STATE(415)] = 29883, + [SMALL_STATE(416)] = 29917, + [SMALL_STATE(417)] = 29953, + [SMALL_STATE(418)] = 29987, + [SMALL_STATE(419)] = 30021, + [SMALL_STATE(420)] = 30055, + [SMALL_STATE(421)] = 30089, + [SMALL_STATE(422)] = 30123, + [SMALL_STATE(423)] = 30157, + [SMALL_STATE(424)] = 30191, + [SMALL_STATE(425)] = 30225, + [SMALL_STATE(426)] = 30259, + [SMALL_STATE(427)] = 30293, + [SMALL_STATE(428)] = 30327, + [SMALL_STATE(429)] = 30361, + [SMALL_STATE(430)] = 30395, + [SMALL_STATE(431)] = 30429, + [SMALL_STATE(432)] = 30463, + [SMALL_STATE(433)] = 30497, + [SMALL_STATE(434)] = 30531, + [SMALL_STATE(435)] = 30565, + [SMALL_STATE(436)] = 30599, + [SMALL_STATE(437)] = 30633, + [SMALL_STATE(438)] = 30667, + [SMALL_STATE(439)] = 30701, + [SMALL_STATE(440)] = 30735, + [SMALL_STATE(441)] = 30769, + [SMALL_STATE(442)] = 30803, + [SMALL_STATE(443)] = 30837, + [SMALL_STATE(444)] = 30871, + [SMALL_STATE(445)] = 30905, + [SMALL_STATE(446)] = 30939, + [SMALL_STATE(447)] = 30973, + [SMALL_STATE(448)] = 31007, + [SMALL_STATE(449)] = 31041, + [SMALL_STATE(450)] = 31075, + [SMALL_STATE(451)] = 31109, + [SMALL_STATE(452)] = 31143, + [SMALL_STATE(453)] = 31177, + [SMALL_STATE(454)] = 31211, + [SMALL_STATE(455)] = 31245, + [SMALL_STATE(456)] = 31279, + [SMALL_STATE(457)] = 31313, + [SMALL_STATE(458)] = 31347, + [SMALL_STATE(459)] = 31381, + [SMALL_STATE(460)] = 31415, + [SMALL_STATE(461)] = 31451, + [SMALL_STATE(462)] = 31485, + [SMALL_STATE(463)] = 31519, + [SMALL_STATE(464)] = 31553, + [SMALL_STATE(465)] = 31587, + [SMALL_STATE(466)] = 31621, + [SMALL_STATE(467)] = 31655, + [SMALL_STATE(468)] = 31689, + [SMALL_STATE(469)] = 31723, + [SMALL_STATE(470)] = 31757, + [SMALL_STATE(471)] = 31793, + [SMALL_STATE(472)] = 31827, + [SMALL_STATE(473)] = 31859, + [SMALL_STATE(474)] = 31891, + [SMALL_STATE(475)] = 31923, + [SMALL_STATE(476)] = 31955, + [SMALL_STATE(477)] = 31989, + [SMALL_STATE(478)] = 32021, + [SMALL_STATE(479)] = 32053, + [SMALL_STATE(480)] = 32085, + [SMALL_STATE(481)] = 32117, + [SMALL_STATE(482)] = 32149, + [SMALL_STATE(483)] = 32181, + [SMALL_STATE(484)] = 32213, + [SMALL_STATE(485)] = 32245, + [SMALL_STATE(486)] = 32277, + [SMALL_STATE(487)] = 32309, + [SMALL_STATE(488)] = 32343, + [SMALL_STATE(489)] = 32375, + [SMALL_STATE(490)] = 32407, + [SMALL_STATE(491)] = 32439, + [SMALL_STATE(492)] = 32471, + [SMALL_STATE(493)] = 32503, + [SMALL_STATE(494)] = 32535, + [SMALL_STATE(495)] = 32567, + [SMALL_STATE(496)] = 32601, + [SMALL_STATE(497)] = 32633, + [SMALL_STATE(498)] = 32665, + [SMALL_STATE(499)] = 32697, + [SMALL_STATE(500)] = 32729, + [SMALL_STATE(501)] = 32761, + [SMALL_STATE(502)] = 32795, + [SMALL_STATE(503)] = 32827, + [SMALL_STATE(504)] = 32859, + [SMALL_STATE(505)] = 32891, + [SMALL_STATE(506)] = 32923, + [SMALL_STATE(507)] = 32955, + [SMALL_STATE(508)] = 32987, + [SMALL_STATE(509)] = 33019, + [SMALL_STATE(510)] = 33051, + [SMALL_STATE(511)] = 33083, + [SMALL_STATE(512)] = 33117, + [SMALL_STATE(513)] = 33149, + [SMALL_STATE(514)] = 33181, + [SMALL_STATE(515)] = 33213, + [SMALL_STATE(516)] = 33245, + [SMALL_STATE(517)] = 33277, + [SMALL_STATE(518)] = 33309, + [SMALL_STATE(519)] = 33341, + [SMALL_STATE(520)] = 33373, + [SMALL_STATE(521)] = 33405, + [SMALL_STATE(522)] = 33437, + [SMALL_STATE(523)] = 33469, + [SMALL_STATE(524)] = 33501, + [SMALL_STATE(525)] = 33533, + [SMALL_STATE(526)] = 33565, + [SMALL_STATE(527)] = 33597, + [SMALL_STATE(528)] = 33629, + [SMALL_STATE(529)] = 33661, + [SMALL_STATE(530)] = 33693, + [SMALL_STATE(531)] = 33725, + [SMALL_STATE(532)] = 33759, + [SMALL_STATE(533)] = 33791, + [SMALL_STATE(534)] = 33823, + [SMALL_STATE(535)] = 33855, + [SMALL_STATE(536)] = 33887, + [SMALL_STATE(537)] = 33919, + [SMALL_STATE(538)] = 33951, + [SMALL_STATE(539)] = 33983, + [SMALL_STATE(540)] = 34015, + [SMALL_STATE(541)] = 34049, + [SMALL_STATE(542)] = 34081, + [SMALL_STATE(543)] = 34113, + [SMALL_STATE(544)] = 34145, + [SMALL_STATE(545)] = 34177, + [SMALL_STATE(546)] = 34209, + [SMALL_STATE(547)] = 34243, + [SMALL_STATE(548)] = 34275, + [SMALL_STATE(549)] = 34307, + [SMALL_STATE(550)] = 34339, + [SMALL_STATE(551)] = 34371, + [SMALL_STATE(552)] = 34403, + [SMALL_STATE(553)] = 34435, + [SMALL_STATE(554)] = 34467, + [SMALL_STATE(555)] = 34499, + [SMALL_STATE(556)] = 34531, + [SMALL_STATE(557)] = 34563, + [SMALL_STATE(558)] = 34595, + [SMALL_STATE(559)] = 34627, + [SMALL_STATE(560)] = 34659, + [SMALL_STATE(561)] = 34691, + [SMALL_STATE(562)] = 34725, + [SMALL_STATE(563)] = 34757, + [SMALL_STATE(564)] = 34789, + [SMALL_STATE(565)] = 34821, + [SMALL_STATE(566)] = 34853, + [SMALL_STATE(567)] = 34885, + [SMALL_STATE(568)] = 34917, + [SMALL_STATE(569)] = 34949, + [SMALL_STATE(570)] = 34981, + [SMALL_STATE(571)] = 35013, + [SMALL_STATE(572)] = 35045, + [SMALL_STATE(573)] = 35077, + [SMALL_STATE(574)] = 35109, + [SMALL_STATE(575)] = 35141, + [SMALL_STATE(576)] = 35173, + [SMALL_STATE(577)] = 35205, + [SMALL_STATE(578)] = 35239, + [SMALL_STATE(579)] = 35271, + [SMALL_STATE(580)] = 35305, + [SMALL_STATE(581)] = 35337, + [SMALL_STATE(582)] = 35369, + [SMALL_STATE(583)] = 35401, + [SMALL_STATE(584)] = 35433, + [SMALL_STATE(585)] = 35465, + [SMALL_STATE(586)] = 35497, + [SMALL_STATE(587)] = 35531, + [SMALL_STATE(588)] = 35563, + [SMALL_STATE(589)] = 35595, + [SMALL_STATE(590)] = 35627, + [SMALL_STATE(591)] = 35659, + [SMALL_STATE(592)] = 35691, + [SMALL_STATE(593)] = 35725, + [SMALL_STATE(594)] = 35757, + [SMALL_STATE(595)] = 35789, + [SMALL_STATE(596)] = 35821, + [SMALL_STATE(597)] = 35853, + [SMALL_STATE(598)] = 35885, + [SMALL_STATE(599)] = 35917, + [SMALL_STATE(600)] = 35949, + [SMALL_STATE(601)] = 35981, + [SMALL_STATE(602)] = 36013, + [SMALL_STATE(603)] = 36045, + [SMALL_STATE(604)] = 36077, + [SMALL_STATE(605)] = 36109, + [SMALL_STATE(606)] = 36141, + [SMALL_STATE(607)] = 36173, + [SMALL_STATE(608)] = 36205, + [SMALL_STATE(609)] = 36237, + [SMALL_STATE(610)] = 36269, + [SMALL_STATE(611)] = 36301, + [SMALL_STATE(612)] = 36333, + [SMALL_STATE(613)] = 36365, + [SMALL_STATE(614)] = 36397, + [SMALL_STATE(615)] = 36429, + [SMALL_STATE(616)] = 36461, + [SMALL_STATE(617)] = 36493, + [SMALL_STATE(618)] = 36525, + [SMALL_STATE(619)] = 36557, + [SMALL_STATE(620)] = 36589, + [SMALL_STATE(621)] = 36621, + [SMALL_STATE(622)] = 36653, + [SMALL_STATE(623)] = 36685, + [SMALL_STATE(624)] = 36717, + [SMALL_STATE(625)] = 36749, + [SMALL_STATE(626)] = 36781, + [SMALL_STATE(627)] = 36813, + [SMALL_STATE(628)] = 36845, + [SMALL_STATE(629)] = 36877, + [SMALL_STATE(630)] = 36909, + [SMALL_STATE(631)] = 36941, + [SMALL_STATE(632)] = 36973, + [SMALL_STATE(633)] = 37005, + [SMALL_STATE(634)] = 37037, + [SMALL_STATE(635)] = 37069, + [SMALL_STATE(636)] = 37101, + [SMALL_STATE(637)] = 37133, + [SMALL_STATE(638)] = 37167, + [SMALL_STATE(639)] = 37199, + [SMALL_STATE(640)] = 37231, + [SMALL_STATE(641)] = 37263, + [SMALL_STATE(642)] = 37295, + [SMALL_STATE(643)] = 37327, + [SMALL_STATE(644)] = 37359, + [SMALL_STATE(645)] = 37391, + [SMALL_STATE(646)] = 37423, + [SMALL_STATE(647)] = 37455, + [SMALL_STATE(648)] = 37487, + [SMALL_STATE(649)] = 37519, + [SMALL_STATE(650)] = 37553, + [SMALL_STATE(651)] = 37585, + [SMALL_STATE(652)] = 37617, + [SMALL_STATE(653)] = 37649, + [SMALL_STATE(654)] = 37681, + [SMALL_STATE(655)] = 37713, + [SMALL_STATE(656)] = 37747, + [SMALL_STATE(657)] = 37779, + [SMALL_STATE(658)] = 37811, + [SMALL_STATE(659)] = 37843, + [SMALL_STATE(660)] = 37875, + [SMALL_STATE(661)] = 37907, + [SMALL_STATE(662)] = 37941, + [SMALL_STATE(663)] = 37973, + [SMALL_STATE(664)] = 38005, + [SMALL_STATE(665)] = 38037, + [SMALL_STATE(666)] = 38069, + [SMALL_STATE(667)] = 38101, + [SMALL_STATE(668)] = 38133, + [SMALL_STATE(669)] = 38165, + [SMALL_STATE(670)] = 38197, + [SMALL_STATE(671)] = 38231, + [SMALL_STATE(672)] = 38263, + [SMALL_STATE(673)] = 38295, + [SMALL_STATE(674)] = 38327, + [SMALL_STATE(675)] = 38359, + [SMALL_STATE(676)] = 38391, + [SMALL_STATE(677)] = 38425, + [SMALL_STATE(678)] = 38457, + [SMALL_STATE(679)] = 38489, + [SMALL_STATE(680)] = 38521, + [SMALL_STATE(681)] = 38553, + [SMALL_STATE(682)] = 38585, + [SMALL_STATE(683)] = 38617, + [SMALL_STATE(684)] = 38649, + [SMALL_STATE(685)] = 38681, + [SMALL_STATE(686)] = 38713, + [SMALL_STATE(687)] = 38745, + [SMALL_STATE(688)] = 38777, + [SMALL_STATE(689)] = 38809, + [SMALL_STATE(690)] = 38841, + [SMALL_STATE(691)] = 38873, + [SMALL_STATE(692)] = 38905, + [SMALL_STATE(693)] = 38937, + [SMALL_STATE(694)] = 38969, + [SMALL_STATE(695)] = 39001, + [SMALL_STATE(696)] = 39033, + [SMALL_STATE(697)] = 39065, + [SMALL_STATE(698)] = 39097, + [SMALL_STATE(699)] = 39129, + [SMALL_STATE(700)] = 39161, + [SMALL_STATE(701)] = 39193, + [SMALL_STATE(702)] = 39225, + [SMALL_STATE(703)] = 39257, + [SMALL_STATE(704)] = 39289, + [SMALL_STATE(705)] = 39321, + [SMALL_STATE(706)] = 39353, + [SMALL_STATE(707)] = 39385, + [SMALL_STATE(708)] = 39417, + [SMALL_STATE(709)] = 39449, + [SMALL_STATE(710)] = 39481, + [SMALL_STATE(711)] = 39513, + [SMALL_STATE(712)] = 39545, + [SMALL_STATE(713)] = 39577, + [SMALL_STATE(714)] = 39609, + [SMALL_STATE(715)] = 39641, + [SMALL_STATE(716)] = 39673, + [SMALL_STATE(717)] = 39705, + [SMALL_STATE(718)] = 39739, + [SMALL_STATE(719)] = 39771, + [SMALL_STATE(720)] = 39803, + [SMALL_STATE(721)] = 39835, + [SMALL_STATE(722)] = 39867, + [SMALL_STATE(723)] = 39899, + [SMALL_STATE(724)] = 39931, + [SMALL_STATE(725)] = 39963, + [SMALL_STATE(726)] = 39997, + [SMALL_STATE(727)] = 40029, + [SMALL_STATE(728)] = 40061, + [SMALL_STATE(729)] = 40093, + [SMALL_STATE(730)] = 40125, + [SMALL_STATE(731)] = 40157, + [SMALL_STATE(732)] = 40191, + [SMALL_STATE(733)] = 40223, + [SMALL_STATE(734)] = 40255, + [SMALL_STATE(735)] = 40287, + [SMALL_STATE(736)] = 40319, + [SMALL_STATE(737)] = 40351, + [SMALL_STATE(738)] = 40383, + [SMALL_STATE(739)] = 40415, + [SMALL_STATE(740)] = 40447, + [SMALL_STATE(741)] = 40479, + [SMALL_STATE(742)] = 40511, + [SMALL_STATE(743)] = 40543, + [SMALL_STATE(744)] = 40575, + [SMALL_STATE(745)] = 40607, + [SMALL_STATE(746)] = 40639, + [SMALL_STATE(747)] = 40671, + [SMALL_STATE(748)] = 40703, + [SMALL_STATE(749)] = 40735, + [SMALL_STATE(750)] = 40767, + [SMALL_STATE(751)] = 40799, + [SMALL_STATE(752)] = 40831, + [SMALL_STATE(753)] = 40863, + [SMALL_STATE(754)] = 40895, + [SMALL_STATE(755)] = 40927, + [SMALL_STATE(756)] = 40959, + [SMALL_STATE(757)] = 40991, + [SMALL_STATE(758)] = 41023, + [SMALL_STATE(759)] = 41055, + [SMALL_STATE(760)] = 41087, + [SMALL_STATE(761)] = 41119, + [SMALL_STATE(762)] = 41153, + [SMALL_STATE(763)] = 41185, + [SMALL_STATE(764)] = 41217, + [SMALL_STATE(765)] = 41249, + [SMALL_STATE(766)] = 41281, + [SMALL_STATE(767)] = 41313, + [SMALL_STATE(768)] = 41345, + [SMALL_STATE(769)] = 41377, + [SMALL_STATE(770)] = 41409, + [SMALL_STATE(771)] = 41443, + [SMALL_STATE(772)] = 41475, + [SMALL_STATE(773)] = 41507, + [SMALL_STATE(774)] = 41539, + [SMALL_STATE(775)] = 41571, + [SMALL_STATE(776)] = 41603, + [SMALL_STATE(777)] = 41637, + [SMALL_STATE(778)] = 41669, + [SMALL_STATE(779)] = 41701, + [SMALL_STATE(780)] = 41733, + [SMALL_STATE(781)] = 41765, + [SMALL_STATE(782)] = 41797, + [SMALL_STATE(783)] = 41829, + [SMALL_STATE(784)] = 41861, + [SMALL_STATE(785)] = 41893, + [SMALL_STATE(786)] = 41925, + [SMALL_STATE(787)] = 41957, + [SMALL_STATE(788)] = 41989, + [SMALL_STATE(789)] = 42021, + [SMALL_STATE(790)] = 42053, + [SMALL_STATE(791)] = 42085, + [SMALL_STATE(792)] = 42117, + [SMALL_STATE(793)] = 42149, + [SMALL_STATE(794)] = 42181, + [SMALL_STATE(795)] = 42213, + [SMALL_STATE(796)] = 42245, + [SMALL_STATE(797)] = 42277, + [SMALL_STATE(798)] = 42309, + [SMALL_STATE(799)] = 42341, + [SMALL_STATE(800)] = 42373, + [SMALL_STATE(801)] = 42405, + [SMALL_STATE(802)] = 42437, + [SMALL_STATE(803)] = 42469, + [SMALL_STATE(804)] = 42501, + [SMALL_STATE(805)] = 42533, + [SMALL_STATE(806)] = 42565, + [SMALL_STATE(807)] = 42597, + [SMALL_STATE(808)] = 42629, + [SMALL_STATE(809)] = 42661, + [SMALL_STATE(810)] = 42695, + [SMALL_STATE(811)] = 42727, + [SMALL_STATE(812)] = 42759, + [SMALL_STATE(813)] = 42791, + [SMALL_STATE(814)] = 42823, + [SMALL_STATE(815)] = 42855, + [SMALL_STATE(816)] = 42887, + [SMALL_STATE(817)] = 42919, + [SMALL_STATE(818)] = 42953, + [SMALL_STATE(819)] = 42985, + [SMALL_STATE(820)] = 43017, + [SMALL_STATE(821)] = 43049, + [SMALL_STATE(822)] = 43081, + [SMALL_STATE(823)] = 43113, + [SMALL_STATE(824)] = 43170, + [SMALL_STATE(825)] = 43227, + [SMALL_STATE(826)] = 43284, + [SMALL_STATE(827)] = 43341, + [SMALL_STATE(828)] = 43398, + [SMALL_STATE(829)] = 43455, + [SMALL_STATE(830)] = 43512, + [SMALL_STATE(831)] = 43569, + [SMALL_STATE(832)] = 43626, + [SMALL_STATE(833)] = 43683, + [SMALL_STATE(834)] = 43740, + [SMALL_STATE(835)] = 43797, + [SMALL_STATE(836)] = 43854, + [SMALL_STATE(837)] = 43911, + [SMALL_STATE(838)] = 43968, + [SMALL_STATE(839)] = 44025, + [SMALL_STATE(840)] = 44082, + [SMALL_STATE(841)] = 44139, + [SMALL_STATE(842)] = 44196, + [SMALL_STATE(843)] = 44253, + [SMALL_STATE(844)] = 44310, + [SMALL_STATE(845)] = 44367, + [SMALL_STATE(846)] = 44424, + [SMALL_STATE(847)] = 44481, + [SMALL_STATE(848)] = 44538, + [SMALL_STATE(849)] = 44595, + [SMALL_STATE(850)] = 44652, + [SMALL_STATE(851)] = 44709, + [SMALL_STATE(852)] = 44766, + [SMALL_STATE(853)] = 44823, + [SMALL_STATE(854)] = 44880, + [SMALL_STATE(855)] = 44937, + [SMALL_STATE(856)] = 44994, + [SMALL_STATE(857)] = 45051, + [SMALL_STATE(858)] = 45108, + [SMALL_STATE(859)] = 45165, + [SMALL_STATE(860)] = 45222, + [SMALL_STATE(861)] = 45279, + [SMALL_STATE(862)] = 45336, + [SMALL_STATE(863)] = 45393, + [SMALL_STATE(864)] = 45450, + [SMALL_STATE(865)] = 45507, + [SMALL_STATE(866)] = 45564, + [SMALL_STATE(867)] = 45621, + [SMALL_STATE(868)] = 45678, + [SMALL_STATE(869)] = 45735, + [SMALL_STATE(870)] = 45792, + [SMALL_STATE(871)] = 45849, + [SMALL_STATE(872)] = 45906, + [SMALL_STATE(873)] = 45963, + [SMALL_STATE(874)] = 46020, + [SMALL_STATE(875)] = 46077, + [SMALL_STATE(876)] = 46134, + [SMALL_STATE(877)] = 46191, + [SMALL_STATE(878)] = 46248, + [SMALL_STATE(879)] = 46305, + [SMALL_STATE(880)] = 46362, + [SMALL_STATE(881)] = 46419, + [SMALL_STATE(882)] = 46476, + [SMALL_STATE(883)] = 46533, + [SMALL_STATE(884)] = 46590, + [SMALL_STATE(885)] = 46647, + [SMALL_STATE(886)] = 46704, + [SMALL_STATE(887)] = 46761, + [SMALL_STATE(888)] = 46818, + [SMALL_STATE(889)] = 46875, + [SMALL_STATE(890)] = 46932, + [SMALL_STATE(891)] = 46989, + [SMALL_STATE(892)] = 47046, + [SMALL_STATE(893)] = 47103, + [SMALL_STATE(894)] = 47160, + [SMALL_STATE(895)] = 47217, + [SMALL_STATE(896)] = 47274, + [SMALL_STATE(897)] = 47331, + [SMALL_STATE(898)] = 47388, + [SMALL_STATE(899)] = 47445, + [SMALL_STATE(900)] = 47502, + [SMALL_STATE(901)] = 47559, + [SMALL_STATE(902)] = 47616, + [SMALL_STATE(903)] = 47673, + [SMALL_STATE(904)] = 47730, + [SMALL_STATE(905)] = 47787, + [SMALL_STATE(906)] = 47844, + [SMALL_STATE(907)] = 47901, + [SMALL_STATE(908)] = 47958, + [SMALL_STATE(909)] = 48015, + [SMALL_STATE(910)] = 48072, + [SMALL_STATE(911)] = 48129, + [SMALL_STATE(912)] = 48186, + [SMALL_STATE(913)] = 48243, + [SMALL_STATE(914)] = 48300, + [SMALL_STATE(915)] = 48357, + [SMALL_STATE(916)] = 48414, + [SMALL_STATE(917)] = 48471, + [SMALL_STATE(918)] = 48528, + [SMALL_STATE(919)] = 48585, + [SMALL_STATE(920)] = 48642, + [SMALL_STATE(921)] = 48699, + [SMALL_STATE(922)] = 48756, + [SMALL_STATE(923)] = 48813, + [SMALL_STATE(924)] = 48870, + [SMALL_STATE(925)] = 48927, + [SMALL_STATE(926)] = 48984, + [SMALL_STATE(927)] = 49041, + [SMALL_STATE(928)] = 49098, + [SMALL_STATE(929)] = 49155, + [SMALL_STATE(930)] = 49212, + [SMALL_STATE(931)] = 49269, + [SMALL_STATE(932)] = 49326, + [SMALL_STATE(933)] = 49383, + [SMALL_STATE(934)] = 49440, + [SMALL_STATE(935)] = 49497, + [SMALL_STATE(936)] = 49554, + [SMALL_STATE(937)] = 49611, + [SMALL_STATE(938)] = 49668, + [SMALL_STATE(939)] = 49725, + [SMALL_STATE(940)] = 49782, + [SMALL_STATE(941)] = 49839, + [SMALL_STATE(942)] = 49896, + [SMALL_STATE(943)] = 49953, + [SMALL_STATE(944)] = 50010, + [SMALL_STATE(945)] = 50067, + [SMALL_STATE(946)] = 50121, + [SMALL_STATE(947)] = 50172, + [SMALL_STATE(948)] = 50220, + [SMALL_STATE(949)] = 50268, + [SMALL_STATE(950)] = 50313, + [SMALL_STATE(951)] = 50357, + [SMALL_STATE(952)] = 50401, + [SMALL_STATE(953)] = 50445, + [SMALL_STATE(954)] = 50489, + [SMALL_STATE(955)] = 50531, + [SMALL_STATE(956)] = 50573, + [SMALL_STATE(957)] = 50617, + [SMALL_STATE(958)] = 50661, + [SMALL_STATE(959)] = 50705, + [SMALL_STATE(960)] = 50749, + [SMALL_STATE(961)] = 50793, + [SMALL_STATE(962)] = 50835, + [SMALL_STATE(963)] = 50877, + [SMALL_STATE(964)] = 50921, + [SMALL_STATE(965)] = 50965, + [SMALL_STATE(966)] = 51009, + [SMALL_STATE(967)] = 51050, + [SMALL_STATE(968)] = 51091, + [SMALL_STATE(969)] = 51132, + [SMALL_STATE(970)] = 51173, + [SMALL_STATE(971)] = 51214, + [SMALL_STATE(972)] = 51255, + [SMALL_STATE(973)] = 51296, + [SMALL_STATE(974)] = 51337, + [SMALL_STATE(975)] = 51378, + [SMALL_STATE(976)] = 51419, + [SMALL_STATE(977)] = 51460, + [SMALL_STATE(978)] = 51501, + [SMALL_STATE(979)] = 51542, + [SMALL_STATE(980)] = 51581, + [SMALL_STATE(981)] = 51622, + [SMALL_STATE(982)] = 51661, + [SMALL_STATE(983)] = 51702, + [SMALL_STATE(984)] = 51743, + [SMALL_STATE(985)] = 51784, + [SMALL_STATE(986)] = 51821, + [SMALL_STATE(987)] = 51862, + [SMALL_STATE(988)] = 51899, + [SMALL_STATE(989)] = 51940, + [SMALL_STATE(990)] = 51981, + [SMALL_STATE(991)] = 52020, + [SMALL_STATE(992)] = 52059, + [SMALL_STATE(993)] = 52100, + [SMALL_STATE(994)] = 52139, + [SMALL_STATE(995)] = 52180, + [SMALL_STATE(996)] = 52221, + [SMALL_STATE(997)] = 52260, + [SMALL_STATE(998)] = 52301, + [SMALL_STATE(999)] = 52342, + [SMALL_STATE(1000)] = 52383, + [SMALL_STATE(1001)] = 52424, + [SMALL_STATE(1002)] = 52465, + [SMALL_STATE(1003)] = 52504, + [SMALL_STATE(1004)] = 52543, + [SMALL_STATE(1005)] = 52584, + [SMALL_STATE(1006)] = 52625, + [SMALL_STATE(1007)] = 52666, + [SMALL_STATE(1008)] = 52705, + [SMALL_STATE(1009)] = 52746, + [SMALL_STATE(1010)] = 52787, + [SMALL_STATE(1011)] = 52828, + [SMALL_STATE(1012)] = 52869, + [SMALL_STATE(1013)] = 52908, + [SMALL_STATE(1014)] = 52947, + [SMALL_STATE(1015)] = 52988, + [SMALL_STATE(1016)] = 53029, + [SMALL_STATE(1017)] = 53070, + [SMALL_STATE(1018)] = 53111, + [SMALL_STATE(1019)] = 53152, + [SMALL_STATE(1020)] = 53193, + [SMALL_STATE(1021)] = 53234, + [SMALL_STATE(1022)] = 53275, + [SMALL_STATE(1023)] = 53316, + [SMALL_STATE(1024)] = 53357, + [SMALL_STATE(1025)] = 53398, + [SMALL_STATE(1026)] = 53437, + [SMALL_STATE(1027)] = 53476, + [SMALL_STATE(1028)] = 53517, + [SMALL_STATE(1029)] = 53558, + [SMALL_STATE(1030)] = 53599, + [SMALL_STATE(1031)] = 53640, + [SMALL_STATE(1032)] = 53681, + [SMALL_STATE(1033)] = 53722, + [SMALL_STATE(1034)] = 53763, + [SMALL_STATE(1035)] = 53804, + [SMALL_STATE(1036)] = 53845, + [SMALL_STATE(1037)] = 53886, + [SMALL_STATE(1038)] = 53927, + [SMALL_STATE(1039)] = 53968, + [SMALL_STATE(1040)] = 54007, + [SMALL_STATE(1041)] = 54048, + [SMALL_STATE(1042)] = 54089, + [SMALL_STATE(1043)] = 54130, + [SMALL_STATE(1044)] = 54171, + [SMALL_STATE(1045)] = 54212, + [SMALL_STATE(1046)] = 54253, + [SMALL_STATE(1047)] = 54294, + [SMALL_STATE(1048)] = 54335, + [SMALL_STATE(1049)] = 54374, + [SMALL_STATE(1050)] = 54415, + [SMALL_STATE(1051)] = 54456, + [SMALL_STATE(1052)] = 54497, + [SMALL_STATE(1053)] = 54538, + [SMALL_STATE(1054)] = 54579, + [SMALL_STATE(1055)] = 54620, + [SMALL_STATE(1056)] = 54661, + [SMALL_STATE(1057)] = 54702, + [SMALL_STATE(1058)] = 54741, + [SMALL_STATE(1059)] = 54782, + [SMALL_STATE(1060)] = 54823, + [SMALL_STATE(1061)] = 54864, + [SMALL_STATE(1062)] = 54905, + [SMALL_STATE(1063)] = 54946, + [SMALL_STATE(1064)] = 54987, + [SMALL_STATE(1065)] = 55028, + [SMALL_STATE(1066)] = 55069, + [SMALL_STATE(1067)] = 55110, + [SMALL_STATE(1068)] = 55151, + [SMALL_STATE(1069)] = 55192, + [SMALL_STATE(1070)] = 55233, + [SMALL_STATE(1071)] = 55274, + [SMALL_STATE(1072)] = 55315, + [SMALL_STATE(1073)] = 55356, + [SMALL_STATE(1074)] = 55397, + [SMALL_STATE(1075)] = 55436, + [SMALL_STATE(1076)] = 55477, + [SMALL_STATE(1077)] = 55518, + [SMALL_STATE(1078)] = 55559, + [SMALL_STATE(1079)] = 55600, + [SMALL_STATE(1080)] = 55641, + [SMALL_STATE(1081)] = 55682, + [SMALL_STATE(1082)] = 55723, + [SMALL_STATE(1083)] = 55764, + [SMALL_STATE(1084)] = 55805, + [SMALL_STATE(1085)] = 55846, + [SMALL_STATE(1086)] = 55887, + [SMALL_STATE(1087)] = 55926, + [SMALL_STATE(1088)] = 55960, + [SMALL_STATE(1089)] = 55994, + [SMALL_STATE(1090)] = 56019, + [SMALL_STATE(1091)] = 56042, + [SMALL_STATE(1092)] = 56065, + [SMALL_STATE(1093)] = 56087, + [SMALL_STATE(1094)] = 56115, + [SMALL_STATE(1095)] = 56143, + [SMALL_STATE(1096)] = 56165, + [SMALL_STATE(1097)] = 56193, + [SMALL_STATE(1098)] = 56221, + [SMALL_STATE(1099)] = 56243, + [SMALL_STATE(1100)] = 56268, + [SMALL_STATE(1101)] = 56293, + [SMALL_STATE(1102)] = 56318, + [SMALL_STATE(1103)] = 56343, + [SMALL_STATE(1104)] = 56368, + [SMALL_STATE(1105)] = 56393, + [SMALL_STATE(1106)] = 56418, + [SMALL_STATE(1107)] = 56443, + [SMALL_STATE(1108)] = 56468, + [SMALL_STATE(1109)] = 56493, + [SMALL_STATE(1110)] = 56518, + [SMALL_STATE(1111)] = 56539, + [SMALL_STATE(1112)] = 56564, + [SMALL_STATE(1113)] = 56589, + [SMALL_STATE(1114)] = 56614, + [SMALL_STATE(1115)] = 56639, + [SMALL_STATE(1116)] = 56664, + [SMALL_STATE(1117)] = 56685, + [SMALL_STATE(1118)] = 56710, + [SMALL_STATE(1119)] = 56731, + [SMALL_STATE(1120)] = 56756, + [SMALL_STATE(1121)] = 56781, + [SMALL_STATE(1122)] = 56806, + [SMALL_STATE(1123)] = 56831, + [SMALL_STATE(1124)] = 56863, + [SMALL_STATE(1125)] = 56895, + [SMALL_STATE(1126)] = 56927, + [SMALL_STATE(1127)] = 56959, + [SMALL_STATE(1128)] = 56991, + [SMALL_STATE(1129)] = 57023, + [SMALL_STATE(1130)] = 57055, + [SMALL_STATE(1131)] = 57087, + [SMALL_STATE(1132)] = 57119, + [SMALL_STATE(1133)] = 57151, + [SMALL_STATE(1134)] = 57183, + [SMALL_STATE(1135)] = 57215, + [SMALL_STATE(1136)] = 57247, + [SMALL_STATE(1137)] = 57279, + [SMALL_STATE(1138)] = 57299, + [SMALL_STATE(1139)] = 57331, + [SMALL_STATE(1140)] = 57351, + [SMALL_STATE(1141)] = 57383, + [SMALL_STATE(1142)] = 57403, + [SMALL_STATE(1143)] = 57435, + [SMALL_STATE(1144)] = 57467, + [SMALL_STATE(1145)] = 57499, + [SMALL_STATE(1146)] = 57531, + [SMALL_STATE(1147)] = 57563, + [SMALL_STATE(1148)] = 57595, + [SMALL_STATE(1149)] = 57627, + [SMALL_STATE(1150)] = 57659, + [SMALL_STATE(1151)] = 57678, + [SMALL_STATE(1152)] = 57697, + [SMALL_STATE(1153)] = 57716, + [SMALL_STATE(1154)] = 57735, + [SMALL_STATE(1155)] = 57754, + [SMALL_STATE(1156)] = 57773, + [SMALL_STATE(1157)] = 57792, + [SMALL_STATE(1158)] = 57811, + [SMALL_STATE(1159)] = 57830, + [SMALL_STATE(1160)] = 57849, + [SMALL_STATE(1161)] = 57868, + [SMALL_STATE(1162)] = 57887, + [SMALL_STATE(1163)] = 57906, + [SMALL_STATE(1164)] = 57925, + [SMALL_STATE(1165)] = 57944, + [SMALL_STATE(1166)] = 57963, + [SMALL_STATE(1167)] = 57990, + [SMALL_STATE(1168)] = 58016, + [SMALL_STATE(1169)] = 58042, + [SMALL_STATE(1170)] = 58068, + [SMALL_STATE(1171)] = 58094, + [SMALL_STATE(1172)] = 58120, + [SMALL_STATE(1173)] = 58146, + [SMALL_STATE(1174)] = 58172, + [SMALL_STATE(1175)] = 58198, + [SMALL_STATE(1176)] = 58224, + [SMALL_STATE(1177)] = 58250, + [SMALL_STATE(1178)] = 58276, + [SMALL_STATE(1179)] = 58302, + [SMALL_STATE(1180)] = 58329, + [SMALL_STATE(1181)] = 58356, + [SMALL_STATE(1182)] = 58383, + [SMALL_STATE(1183)] = 58410, + [SMALL_STATE(1184)] = 58433, + [SMALL_STATE(1185)] = 58460, + [SMALL_STATE(1186)] = 58487, + [SMALL_STATE(1187)] = 58510, + [SMALL_STATE(1188)] = 58537, + [SMALL_STATE(1189)] = 58564, + [SMALL_STATE(1190)] = 58591, + [SMALL_STATE(1191)] = 58618, + [SMALL_STATE(1192)] = 58645, + [SMALL_STATE(1193)] = 58672, + [SMALL_STATE(1194)] = 58699, + [SMALL_STATE(1195)] = 58721, + [SMALL_STATE(1196)] = 58743, + [SMALL_STATE(1197)] = 58765, + [SMALL_STATE(1198)] = 58787, + [SMALL_STATE(1199)] = 58809, + [SMALL_STATE(1200)] = 58831, + [SMALL_STATE(1201)] = 58853, + [SMALL_STATE(1202)] = 58875, + [SMALL_STATE(1203)] = 58897, + [SMALL_STATE(1204)] = 58919, + [SMALL_STATE(1205)] = 58941, + [SMALL_STATE(1206)] = 58963, + [SMALL_STATE(1207)] = 58985, + [SMALL_STATE(1208)] = 59007, + [SMALL_STATE(1209)] = 59029, + [SMALL_STATE(1210)] = 59051, + [SMALL_STATE(1211)] = 59073, + [SMALL_STATE(1212)] = 59095, + [SMALL_STATE(1213)] = 59117, + [SMALL_STATE(1214)] = 59139, + [SMALL_STATE(1215)] = 59161, + [SMALL_STATE(1216)] = 59183, + [SMALL_STATE(1217)] = 59205, + [SMALL_STATE(1218)] = 59227, + [SMALL_STATE(1219)] = 59244, + [SMALL_STATE(1220)] = 59262, + [SMALL_STATE(1221)] = 59280, + [SMALL_STATE(1222)] = 59298, + [SMALL_STATE(1223)] = 59316, + [SMALL_STATE(1224)] = 59334, + [SMALL_STATE(1225)] = 59352, + [SMALL_STATE(1226)] = 59370, + [SMALL_STATE(1227)] = 59386, + [SMALL_STATE(1228)] = 59402, + [SMALL_STATE(1229)] = 59420, + [SMALL_STATE(1230)] = 59438, + [SMALL_STATE(1231)] = 59456, + [SMALL_STATE(1232)] = 59474, + [SMALL_STATE(1233)] = 59492, + [SMALL_STATE(1234)] = 59510, + [SMALL_STATE(1235)] = 59528, + [SMALL_STATE(1236)] = 59546, + [SMALL_STATE(1237)] = 59564, + [SMALL_STATE(1238)] = 59580, + [SMALL_STATE(1239)] = 59596, + [SMALL_STATE(1240)] = 59614, + [SMALL_STATE(1241)] = 59632, + [SMALL_STATE(1242)] = 59650, + [SMALL_STATE(1243)] = 59668, + [SMALL_STATE(1244)] = 59684, + [SMALL_STATE(1245)] = 59702, + [SMALL_STATE(1246)] = 59720, + [SMALL_STATE(1247)] = 59738, + [SMALL_STATE(1248)] = 59756, + [SMALL_STATE(1249)] = 59774, + [SMALL_STATE(1250)] = 59792, + [SMALL_STATE(1251)] = 59810, + [SMALL_STATE(1252)] = 59828, + [SMALL_STATE(1253)] = 59846, + [SMALL_STATE(1254)] = 59864, + [SMALL_STATE(1255)] = 59882, + [SMALL_STATE(1256)] = 59898, + [SMALL_STATE(1257)] = 59914, + [SMALL_STATE(1258)] = 59932, + [SMALL_STATE(1259)] = 59950, + [SMALL_STATE(1260)] = 59968, + [SMALL_STATE(1261)] = 59986, + [SMALL_STATE(1262)] = 60004, + [SMALL_STATE(1263)] = 60022, + [SMALL_STATE(1264)] = 60040, + [SMALL_STATE(1265)] = 60058, + [SMALL_STATE(1266)] = 60074, + [SMALL_STATE(1267)] = 60090, + [SMALL_STATE(1268)] = 60106, + [SMALL_STATE(1269)] = 60124, + [SMALL_STATE(1270)] = 60142, + [SMALL_STATE(1271)] = 60160, + [SMALL_STATE(1272)] = 60178, + [SMALL_STATE(1273)] = 60194, + [SMALL_STATE(1274)] = 60212, + [SMALL_STATE(1275)] = 60230, + [SMALL_STATE(1276)] = 60248, + [SMALL_STATE(1277)] = 60266, + [SMALL_STATE(1278)] = 60284, + [SMALL_STATE(1279)] = 60302, + [SMALL_STATE(1280)] = 60320, + [SMALL_STATE(1281)] = 60338, + [SMALL_STATE(1282)] = 60356, + [SMALL_STATE(1283)] = 60372, + [SMALL_STATE(1284)] = 60388, + [SMALL_STATE(1285)] = 60406, + [SMALL_STATE(1286)] = 60424, + [SMALL_STATE(1287)] = 60442, + [SMALL_STATE(1288)] = 60460, + [SMALL_STATE(1289)] = 60478, + [SMALL_STATE(1290)] = 60496, + [SMALL_STATE(1291)] = 60512, + [SMALL_STATE(1292)] = 60528, + [SMALL_STATE(1293)] = 60546, + [SMALL_STATE(1294)] = 60564, + [SMALL_STATE(1295)] = 60582, + [SMALL_STATE(1296)] = 60600, + [SMALL_STATE(1297)] = 60618, + [SMALL_STATE(1298)] = 60636, + [SMALL_STATE(1299)] = 60654, + [SMALL_STATE(1300)] = 60672, + [SMALL_STATE(1301)] = 60690, + [SMALL_STATE(1302)] = 60706, + [SMALL_STATE(1303)] = 60722, + [SMALL_STATE(1304)] = 60740, + [SMALL_STATE(1305)] = 60758, + [SMALL_STATE(1306)] = 60776, + [SMALL_STATE(1307)] = 60794, + [SMALL_STATE(1308)] = 60812, + [SMALL_STATE(1309)] = 60830, + [SMALL_STATE(1310)] = 60848, + [SMALL_STATE(1311)] = 60866, + [SMALL_STATE(1312)] = 60884, + [SMALL_STATE(1313)] = 60902, + [SMALL_STATE(1314)] = 60920, + [SMALL_STATE(1315)] = 60938, + [SMALL_STATE(1316)] = 60954, + [SMALL_STATE(1317)] = 60970, + [SMALL_STATE(1318)] = 60988, + [SMALL_STATE(1319)] = 61006, + [SMALL_STATE(1320)] = 61024, + [SMALL_STATE(1321)] = 61042, + [SMALL_STATE(1322)] = 61060, + [SMALL_STATE(1323)] = 61078, + [SMALL_STATE(1324)] = 61096, + [SMALL_STATE(1325)] = 61114, + [SMALL_STATE(1326)] = 61132, + [SMALL_STATE(1327)] = 61148, + [SMALL_STATE(1328)] = 61164, + [SMALL_STATE(1329)] = 61182, + [SMALL_STATE(1330)] = 61200, + [SMALL_STATE(1331)] = 61218, + [SMALL_STATE(1332)] = 61236, + [SMALL_STATE(1333)] = 61252, + [SMALL_STATE(1334)] = 61270, + [SMALL_STATE(1335)] = 61288, + [SMALL_STATE(1336)] = 61306, + [SMALL_STATE(1337)] = 61324, + [SMALL_STATE(1338)] = 61342, + [SMALL_STATE(1339)] = 61360, + [SMALL_STATE(1340)] = 61378, + [SMALL_STATE(1341)] = 61394, + [SMALL_STATE(1342)] = 61410, + [SMALL_STATE(1343)] = 61428, + [SMALL_STATE(1344)] = 61446, + [SMALL_STATE(1345)] = 61464, + [SMALL_STATE(1346)] = 61482, + [SMALL_STATE(1347)] = 61500, + [SMALL_STATE(1348)] = 61518, + [SMALL_STATE(1349)] = 61536, + [SMALL_STATE(1350)] = 61554, + [SMALL_STATE(1351)] = 61570, + [SMALL_STATE(1352)] = 61586, + [SMALL_STATE(1353)] = 61602, + [SMALL_STATE(1354)] = 61620, + [SMALL_STATE(1355)] = 61638, + [SMALL_STATE(1356)] = 61656, + [SMALL_STATE(1357)] = 61674, + [SMALL_STATE(1358)] = 61692, + [SMALL_STATE(1359)] = 61710, + [SMALL_STATE(1360)] = 61728, + [SMALL_STATE(1361)] = 61746, + [SMALL_STATE(1362)] = 61764, + [SMALL_STATE(1363)] = 61782, + [SMALL_STATE(1364)] = 61800, + [SMALL_STATE(1365)] = 61816, + [SMALL_STATE(1366)] = 61832, + [SMALL_STATE(1367)] = 61850, + [SMALL_STATE(1368)] = 61868, + [SMALL_STATE(1369)] = 61886, + [SMALL_STATE(1370)] = 61904, + [SMALL_STATE(1371)] = 61922, + [SMALL_STATE(1372)] = 61940, + [SMALL_STATE(1373)] = 61958, + [SMALL_STATE(1374)] = 61976, + [SMALL_STATE(1375)] = 61994, + [SMALL_STATE(1376)] = 62010, + [SMALL_STATE(1377)] = 62026, + [SMALL_STATE(1378)] = 62044, + [SMALL_STATE(1379)] = 62062, + [SMALL_STATE(1380)] = 62080, + [SMALL_STATE(1381)] = 62098, + [SMALL_STATE(1382)] = 62116, + [SMALL_STATE(1383)] = 62134, + [SMALL_STATE(1384)] = 62152, + [SMALL_STATE(1385)] = 62170, + [SMALL_STATE(1386)] = 62186, + [SMALL_STATE(1387)] = 62202, + [SMALL_STATE(1388)] = 62220, + [SMALL_STATE(1389)] = 62238, + [SMALL_STATE(1390)] = 62256, + [SMALL_STATE(1391)] = 62274, + [SMALL_STATE(1392)] = 62292, + [SMALL_STATE(1393)] = 62308, + [SMALL_STATE(1394)] = 62324, + [SMALL_STATE(1395)] = 62342, + [SMALL_STATE(1396)] = 62358, + [SMALL_STATE(1397)] = 62374, + [SMALL_STATE(1398)] = 62392, + [SMALL_STATE(1399)] = 62406, + [SMALL_STATE(1400)] = 62420, + [SMALL_STATE(1401)] = 62438, + [SMALL_STATE(1402)] = 62456, + [SMALL_STATE(1403)] = 62474, + [SMALL_STATE(1404)] = 62492, + [SMALL_STATE(1405)] = 62508, + [SMALL_STATE(1406)] = 62526, + [SMALL_STATE(1407)] = 62544, + [SMALL_STATE(1408)] = 62562, + [SMALL_STATE(1409)] = 62578, + [SMALL_STATE(1410)] = 62592, + [SMALL_STATE(1411)] = 62610, + [SMALL_STATE(1412)] = 62626, + [SMALL_STATE(1413)] = 62642, + [SMALL_STATE(1414)] = 62660, + [SMALL_STATE(1415)] = 62678, + [SMALL_STATE(1416)] = 62696, + [SMALL_STATE(1417)] = 62714, + [SMALL_STATE(1418)] = 62728, + [SMALL_STATE(1419)] = 62742, + [SMALL_STATE(1420)] = 62760, + [SMALL_STATE(1421)] = 62778, + [SMALL_STATE(1422)] = 62796, + [SMALL_STATE(1423)] = 62814, + [SMALL_STATE(1424)] = 62832, + [SMALL_STATE(1425)] = 62850, + [SMALL_STATE(1426)] = 62864, + [SMALL_STATE(1427)] = 62878, + [SMALL_STATE(1428)] = 62896, + [SMALL_STATE(1429)] = 62912, + [SMALL_STATE(1430)] = 62928, + [SMALL_STATE(1431)] = 62944, + [SMALL_STATE(1432)] = 62962, + [SMALL_STATE(1433)] = 62980, + [SMALL_STATE(1434)] = 62998, + [SMALL_STATE(1435)] = 63012, + [SMALL_STATE(1436)] = 63026, + [SMALL_STATE(1437)] = 63044, + [SMALL_STATE(1438)] = 63062, + [SMALL_STATE(1439)] = 63076, + [SMALL_STATE(1440)] = 63090, + [SMALL_STATE(1441)] = 63108, + [SMALL_STATE(1442)] = 63126, + [SMALL_STATE(1443)] = 63144, + [SMALL_STATE(1444)] = 63162, + [SMALL_STATE(1445)] = 63180, + [SMALL_STATE(1446)] = 63198, + [SMALL_STATE(1447)] = 63216, + [SMALL_STATE(1448)] = 63230, + [SMALL_STATE(1449)] = 63244, + [SMALL_STATE(1450)] = 63262, + [SMALL_STATE(1451)] = 63280, + [SMALL_STATE(1452)] = 63296, + [SMALL_STATE(1453)] = 63314, + [SMALL_STATE(1454)] = 63330, + [SMALL_STATE(1455)] = 63348, + [SMALL_STATE(1456)] = 63366, + [SMALL_STATE(1457)] = 63380, + [SMALL_STATE(1458)] = 63394, + [SMALL_STATE(1459)] = 63412, + [SMALL_STATE(1460)] = 63430, + [SMALL_STATE(1461)] = 63448, + [SMALL_STATE(1462)] = 63466, + [SMALL_STATE(1463)] = 63484, + [SMALL_STATE(1464)] = 63498, + [SMALL_STATE(1465)] = 63512, + [SMALL_STATE(1466)] = 63530, + [SMALL_STATE(1467)] = 63548, + [SMALL_STATE(1468)] = 63564, + [SMALL_STATE(1469)] = 63580, + [SMALL_STATE(1470)] = 63598, + [SMALL_STATE(1471)] = 63616, + [SMALL_STATE(1472)] = 63634, + [SMALL_STATE(1473)] = 63652, + [SMALL_STATE(1474)] = 63666, + [SMALL_STATE(1475)] = 63680, + [SMALL_STATE(1476)] = 63698, + [SMALL_STATE(1477)] = 63716, + [SMALL_STATE(1478)] = 63734, + [SMALL_STATE(1479)] = 63750, + [SMALL_STATE(1480)] = 63768, + [SMALL_STATE(1481)] = 63784, + [SMALL_STATE(1482)] = 63798, + [SMALL_STATE(1483)] = 63812, + [SMALL_STATE(1484)] = 63828, + [SMALL_STATE(1485)] = 63846, + [SMALL_STATE(1486)] = 63864, + [SMALL_STATE(1487)] = 63882, + [SMALL_STATE(1488)] = 63900, + [SMALL_STATE(1489)] = 63916, + [SMALL_STATE(1490)] = 63930, + [SMALL_STATE(1491)] = 63946, + [SMALL_STATE(1492)] = 63962, + [SMALL_STATE(1493)] = 63978, + [SMALL_STATE(1494)] = 63994, + [SMALL_STATE(1495)] = 64012, + [SMALL_STATE(1496)] = 64030, + [SMALL_STATE(1497)] = 64046, + [SMALL_STATE(1498)] = 64064, + [SMALL_STATE(1499)] = 64082, + [SMALL_STATE(1500)] = 64098, + [SMALL_STATE(1501)] = 64116, + [SMALL_STATE(1502)] = 64132, + [SMALL_STATE(1503)] = 64148, + [SMALL_STATE(1504)] = 64166, + [SMALL_STATE(1505)] = 64184, + [SMALL_STATE(1506)] = 64202, + [SMALL_STATE(1507)] = 64220, + [SMALL_STATE(1508)] = 64238, + [SMALL_STATE(1509)] = 64256, + [SMALL_STATE(1510)] = 64274, + [SMALL_STATE(1511)] = 64292, + [SMALL_STATE(1512)] = 64308, + [SMALL_STATE(1513)] = 64324, + [SMALL_STATE(1514)] = 64342, + [SMALL_STATE(1515)] = 64360, + [SMALL_STATE(1516)] = 64376, + [SMALL_STATE(1517)] = 64394, + [SMALL_STATE(1518)] = 64412, + [SMALL_STATE(1519)] = 64430, + [SMALL_STATE(1520)] = 64448, + [SMALL_STATE(1521)] = 64466, + [SMALL_STATE(1522)] = 64484, + [SMALL_STATE(1523)] = 64502, + [SMALL_STATE(1524)] = 64520, + [SMALL_STATE(1525)] = 64538, + [SMALL_STATE(1526)] = 64554, + [SMALL_STATE(1527)] = 64570, + [SMALL_STATE(1528)] = 64588, + [SMALL_STATE(1529)] = 64606, + [SMALL_STATE(1530)] = 64624, + [SMALL_STATE(1531)] = 64642, + [SMALL_STATE(1532)] = 64660, + [SMALL_STATE(1533)] = 64678, + [SMALL_STATE(1534)] = 64696, + [SMALL_STATE(1535)] = 64714, + [SMALL_STATE(1536)] = 64732, + [SMALL_STATE(1537)] = 64746, + [SMALL_STATE(1538)] = 64762, + [SMALL_STATE(1539)] = 64776, + [SMALL_STATE(1540)] = 64791, + [SMALL_STATE(1541)] = 64806, + [SMALL_STATE(1542)] = 64821, + [SMALL_STATE(1543)] = 64836, + [SMALL_STATE(1544)] = 64851, + [SMALL_STATE(1545)] = 64866, + [SMALL_STATE(1546)] = 64881, + [SMALL_STATE(1547)] = 64896, + [SMALL_STATE(1548)] = 64911, + [SMALL_STATE(1549)] = 64926, + [SMALL_STATE(1550)] = 64937, + [SMALL_STATE(1551)] = 64952, + [SMALL_STATE(1552)] = 64967, + [SMALL_STATE(1553)] = 64980, + [SMALL_STATE(1554)] = 64995, + [SMALL_STATE(1555)] = 65006, + [SMALL_STATE(1556)] = 65021, + [SMALL_STATE(1557)] = 65036, + [SMALL_STATE(1558)] = 65051, + [SMALL_STATE(1559)] = 65062, + [SMALL_STATE(1560)] = 65073, + [SMALL_STATE(1561)] = 65088, + [SMALL_STATE(1562)] = 65103, + [SMALL_STATE(1563)] = 65114, + [SMALL_STATE(1564)] = 65129, + [SMALL_STATE(1565)] = 65144, + [SMALL_STATE(1566)] = 65159, + [SMALL_STATE(1567)] = 65171, + [SMALL_STATE(1568)] = 65183, + [SMALL_STATE(1569)] = 65195, + [SMALL_STATE(1570)] = 65207, + [SMALL_STATE(1571)] = 65219, + [SMALL_STATE(1572)] = 65231, + [SMALL_STATE(1573)] = 65243, + [SMALL_STATE(1574)] = 65255, + [SMALL_STATE(1575)] = 65267, + [SMALL_STATE(1576)] = 65279, + [SMALL_STATE(1577)] = 65289, + [SMALL_STATE(1578)] = 65301, + [SMALL_STATE(1579)] = 65313, + [SMALL_STATE(1580)] = 65325, + [SMALL_STATE(1581)] = 65337, + [SMALL_STATE(1582)] = 65347, + [SMALL_STATE(1583)] = 65359, + [SMALL_STATE(1584)] = 65371, + [SMALL_STATE(1585)] = 65381, + [SMALL_STATE(1586)] = 65393, + [SMALL_STATE(1587)] = 65405, + [SMALL_STATE(1588)] = 65417, + [SMALL_STATE(1589)] = 65429, + [SMALL_STATE(1590)] = 65441, + [SMALL_STATE(1591)] = 65453, + [SMALL_STATE(1592)] = 65465, + [SMALL_STATE(1593)] = 65477, + [SMALL_STATE(1594)] = 65489, + [SMALL_STATE(1595)] = 65498, + [SMALL_STATE(1596)] = 65507, + [SMALL_STATE(1597)] = 65516, + [SMALL_STATE(1598)] = 65525, + [SMALL_STATE(1599)] = 65534, + [SMALL_STATE(1600)] = 65543, + [SMALL_STATE(1601)] = 65552, + [SMALL_STATE(1602)] = 65561, + [SMALL_STATE(1603)] = 65570, + [SMALL_STATE(1604)] = 65579, + [SMALL_STATE(1605)] = 65588, + [SMALL_STATE(1606)] = 65597, + [SMALL_STATE(1607)] = 65606, + [SMALL_STATE(1608)] = 65615, + [SMALL_STATE(1609)] = 65624, + [SMALL_STATE(1610)] = 65633, + [SMALL_STATE(1611)] = 65642, + [SMALL_STATE(1612)] = 65651, + [SMALL_STATE(1613)] = 65660, + [SMALL_STATE(1614)] = 65669, + [SMALL_STATE(1615)] = 65678, + [SMALL_STATE(1616)] = 65687, + [SMALL_STATE(1617)] = 65696, + [SMALL_STATE(1618)] = 65705, + [SMALL_STATE(1619)] = 65714, + [SMALL_STATE(1620)] = 65723, + [SMALL_STATE(1621)] = 65732, + [SMALL_STATE(1622)] = 65741, + [SMALL_STATE(1623)] = 65750, + [SMALL_STATE(1624)] = 65759, + [SMALL_STATE(1625)] = 65768, + [SMALL_STATE(1626)] = 65777, + [SMALL_STATE(1627)] = 65786, + [SMALL_STATE(1628)] = 65795, + [SMALL_STATE(1629)] = 65804, + [SMALL_STATE(1630)] = 65813, + [SMALL_STATE(1631)] = 65822, + [SMALL_STATE(1632)] = 65831, + [SMALL_STATE(1633)] = 65840, + [SMALL_STATE(1634)] = 65849, + [SMALL_STATE(1635)] = 65858, + [SMALL_STATE(1636)] = 65867, + [SMALL_STATE(1637)] = 65876, + [SMALL_STATE(1638)] = 65885, + [SMALL_STATE(1639)] = 65894, + [SMALL_STATE(1640)] = 65903, + [SMALL_STATE(1641)] = 65912, + [SMALL_STATE(1642)] = 65921, + [SMALL_STATE(1643)] = 65930, + [SMALL_STATE(1644)] = 65939, + [SMALL_STATE(1645)] = 65948, + [SMALL_STATE(1646)] = 65957, + [SMALL_STATE(1647)] = 65966, + [SMALL_STATE(1648)] = 65975, + [SMALL_STATE(1649)] = 65984, + [SMALL_STATE(1650)] = 65993, + [SMALL_STATE(1651)] = 66002, + [SMALL_STATE(1652)] = 66011, + [SMALL_STATE(1653)] = 66020, + [SMALL_STATE(1654)] = 66029, + [SMALL_STATE(1655)] = 66038, + [SMALL_STATE(1656)] = 66047, + [SMALL_STATE(1657)] = 66056, + [SMALL_STATE(1658)] = 66065, + [SMALL_STATE(1659)] = 66074, + [SMALL_STATE(1660)] = 66083, + [SMALL_STATE(1661)] = 66092, + [SMALL_STATE(1662)] = 66101, + [SMALL_STATE(1663)] = 66110, + [SMALL_STATE(1664)] = 66119, + [SMALL_STATE(1665)] = 66128, + [SMALL_STATE(1666)] = 66137, + [SMALL_STATE(1667)] = 66146, + [SMALL_STATE(1668)] = 66155, + [SMALL_STATE(1669)] = 66164, + [SMALL_STATE(1670)] = 66173, + [SMALL_STATE(1671)] = 66182, + [SMALL_STATE(1672)] = 66191, + [SMALL_STATE(1673)] = 66200, + [SMALL_STATE(1674)] = 66209, + [SMALL_STATE(1675)] = 66218, + [SMALL_STATE(1676)] = 66227, + [SMALL_STATE(1677)] = 66236, + [SMALL_STATE(1678)] = 66245, + [SMALL_STATE(1679)] = 66254, + [SMALL_STATE(1680)] = 66263, + [SMALL_STATE(1681)] = 66272, + [SMALL_STATE(1682)] = 66281, + [SMALL_STATE(1683)] = 66290, + [SMALL_STATE(1684)] = 66299, + [SMALL_STATE(1685)] = 66308, + [SMALL_STATE(1686)] = 66317, + [SMALL_STATE(1687)] = 66326, + [SMALL_STATE(1688)] = 66335, + [SMALL_STATE(1689)] = 66344, + [SMALL_STATE(1690)] = 66353, + [SMALL_STATE(1691)] = 66362, + [SMALL_STATE(1692)] = 66371, + [SMALL_STATE(1693)] = 66380, + [SMALL_STATE(1694)] = 66389, + [SMALL_STATE(1695)] = 66398, + [SMALL_STATE(1696)] = 66407, + [SMALL_STATE(1697)] = 66416, + [SMALL_STATE(1698)] = 66425, + [SMALL_STATE(1699)] = 66434, + [SMALL_STATE(1700)] = 66443, + [SMALL_STATE(1701)] = 66452, + [SMALL_STATE(1702)] = 66461, + [SMALL_STATE(1703)] = 66470, + [SMALL_STATE(1704)] = 66479, + [SMALL_STATE(1705)] = 66488, + [SMALL_STATE(1706)] = 66497, + [SMALL_STATE(1707)] = 66506, + [SMALL_STATE(1708)] = 66515, + [SMALL_STATE(1709)] = 66524, + [SMALL_STATE(1710)] = 66533, + [SMALL_STATE(1711)] = 66542, + [SMALL_STATE(1712)] = 66551, + [SMALL_STATE(1713)] = 66560, + [SMALL_STATE(1714)] = 66569, + [SMALL_STATE(1715)] = 66578, + [SMALL_STATE(1716)] = 66587, + [SMALL_STATE(1717)] = 66596, + [SMALL_STATE(1718)] = 66605, + [SMALL_STATE(1719)] = 66614, + [SMALL_STATE(1720)] = 66623, + [SMALL_STATE(1721)] = 66632, + [SMALL_STATE(1722)] = 66641, + [SMALL_STATE(1723)] = 66650, + [SMALL_STATE(1724)] = 66659, + [SMALL_STATE(1725)] = 66668, + [SMALL_STATE(1726)] = 66677, + [SMALL_STATE(1727)] = 66686, + [SMALL_STATE(1728)] = 66695, + [SMALL_STATE(1729)] = 66704, + [SMALL_STATE(1730)] = 66713, + [SMALL_STATE(1731)] = 66722, + [SMALL_STATE(1732)] = 66731, + [SMALL_STATE(1733)] = 66740, + [SMALL_STATE(1734)] = 66749, + [SMALL_STATE(1735)] = 66758, + [SMALL_STATE(1736)] = 66767, + [SMALL_STATE(1737)] = 66776, + [SMALL_STATE(1738)] = 66785, + [SMALL_STATE(1739)] = 66794, + [SMALL_STATE(1740)] = 66803, + [SMALL_STATE(1741)] = 66812, + [SMALL_STATE(1742)] = 66821, + [SMALL_STATE(1743)] = 66830, + [SMALL_STATE(1744)] = 66839, + [SMALL_STATE(1745)] = 66848, + [SMALL_STATE(1746)] = 66857, + [SMALL_STATE(1747)] = 66866, + [SMALL_STATE(1748)] = 66875, + [SMALL_STATE(1749)] = 66884, + [SMALL_STATE(1750)] = 66893, + [SMALL_STATE(1751)] = 66902, + [SMALL_STATE(1752)] = 66911, + [SMALL_STATE(1753)] = 66920, + [SMALL_STATE(1754)] = 66929, + [SMALL_STATE(1755)] = 66938, + [SMALL_STATE(1756)] = 66947, + [SMALL_STATE(1757)] = 66956, + [SMALL_STATE(1758)] = 66965, + [SMALL_STATE(1759)] = 66974, + [SMALL_STATE(1760)] = 66983, + [SMALL_STATE(1761)] = 66992, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1542), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1551), + [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1545), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1470), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1180), + [19] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1419), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1236), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1276), + [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1367), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(873), + [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(916), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1669), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(872), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(114), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1172), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), + [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), + [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1489), + [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(356), + [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1576), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1552), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1739), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1095), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1089), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1619), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1526), + [65] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [67] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [69] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1542), + [72] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1551), + [75] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1545), + [78] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(293), + [81] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1470), + [84] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1180), + [87] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1419), + [90] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1236), + [93] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1276), + [96] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1367), + [99] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1658), + [102] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(873), + [105] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(916), + [108] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1669), + [111] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(872), + [114] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(114), + [117] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1172), + [120] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1478), + [123] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1488), + [126] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1489), + [129] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(356), + [132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), + [134] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1249), + [136] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1192), + [138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1222), + [140] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1223), + [142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1224), + [144] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1225), + [146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(892), + [148] = {.entry = {.count = 1, .reusable = false}}, SHIFT(486), + [150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(824), + [152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(169), + [154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(893), + [156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1755), + [158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(894), + [160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(217), + [162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1169), + [164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1438), + [166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(376), + [168] = {.entry = {.count = 1, .reusable = false}}, SHIFT(716), + [170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(329), + [172] = {.entry = {.count = 1, .reusable = false}}, SHIFT(373), + [174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(815), + [176] = {.entry = {.count = 1, .reusable = false}}, SHIFT(808), + [178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(646), + [180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(636), + [182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(525), + [184] = {.entry = {.count = 1, .reusable = false}}, SHIFT(502), + [186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(723), + [188] = {.entry = {.count = 1, .reusable = false}}, SHIFT(760), + [190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(768), + [192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(401), + [194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(408), + [196] = {.entry = {.count = 1, .reusable = false}}, SHIFT(445), + [198] = {.entry = {.count = 1, .reusable = false}}, SHIFT(493), + [200] = {.entry = {.count = 1, .reusable = false}}, SHIFT(530), + [202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(538), + [204] = {.entry = {.count = 1, .reusable = false}}, SHIFT(576), + [206] = {.entry = {.count = 1, .reusable = false}}, SHIFT(584), + [208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(469), + [210] = {.entry = {.count = 1, .reusable = false}}, SHIFT(660), + [212] = {.entry = {.count = 1, .reusable = false}}, SHIFT(668), + [214] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(461), + [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1369), + [220] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1193), + [223] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1336), + [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1337), + [229] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1338), + [232] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1339), + [235] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1658), + [238] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(919), + [241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), + [243] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(920), + [246] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1759), + [249] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(921), + [252] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(225), + [255] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1167), + [258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), + [260] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1478), + [263] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1488), + [266] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1473), + [269] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(462), + [272] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(393), + [275] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1249), + [278] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1192), + [281] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1222), + [284] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1223), + [287] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1224), + [290] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1225), + [293] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(892), + [296] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(893), + [299] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1755), + [302] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(894), + [305] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(217), + [308] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1169), + [311] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1438), + [314] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(376), + [317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(461), + [319] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1369), + [321] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1193), + [323] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1336), + [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1337), + [327] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1338), + [329] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1339), + [331] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_item, 2, 0, 0), SHIFT(1658), + [334] = {.entry = {.count = 1, .reusable = false}}, SHIFT(919), + [336] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_item, 2, 0, 0), + [338] = {.entry = {.count = 1, .reusable = false}}, SHIFT(920), + [340] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1759), + [342] = {.entry = {.count = 1, .reusable = false}}, SHIFT(921), + [344] = {.entry = {.count = 1, .reusable = false}}, SHIFT(225), + [346] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1167), + [348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_item, 2, 0, 0), + [350] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_case_item, 2, 0, 0), SHIFT(1473), + [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(462), + [355] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elsif_clause, 4, 0, 0), + [357] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_elsif_clause, 3, 0, 0), + [359] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_item, 3, 0, 0), SHIFT(1658), + [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_item, 3, 0, 0), + [364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_item, 3, 0, 0), + [366] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_case_item, 3, 0, 0), SHIFT(1473), + [369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(484), + [371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1357), + [373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1181), + [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1246), + [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1247), + [379] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1248), + [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1250), + [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(869), + [385] = {.entry = {.count = 1, .reusable = false}}, SHIFT(870), + [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1751), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(871), + [391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(209), + [393] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1176), + [395] = {.entry = {.count = 1, .reusable = false}}, SHIFT(265), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1538), + [399] = {.entry = {.count = 1, .reusable = false}}, SHIFT(485), + [401] = {.entry = {.count = 1, .reusable = false}}, SHIFT(316), + [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(739), + [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1221), + [407] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1182), + [409] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1495), + [411] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1497), + [413] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1498), + [415] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1500), + [417] = {.entry = {.count = 1, .reusable = false}}, SHIFT(886), + [419] = {.entry = {.count = 1, .reusable = false}}, SHIFT(887), + [421] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1754), + [423] = {.entry = {.count = 1, .reusable = false}}, SHIFT(888), + [425] = {.entry = {.count = 1, .reusable = false}}, SHIFT(215), + [427] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1177), + [429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1434), + [431] = {.entry = {.count = 1, .reusable = false}}, SHIFT(740), + [433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(509), + [435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1310), + [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1184), + [439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1286), + [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1287), + [443] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1288), + [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1289), + [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(906), + [449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_clause, 2, 0, 0), + [451] = {.entry = {.count = 1, .reusable = false}}, SHIFT(907), + [453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1757), + [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(908), + [457] = {.entry = {.count = 1, .reusable = false}}, SHIFT(221), + [459] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1178), + [461] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1456), + [463] = {.entry = {.count = 1, .reusable = false}}, SHIFT(510), + [465] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), + [467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), + [469] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1442), + [471] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1185), + [473] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1359), + [475] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1361), + [477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1362), + [479] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1363), + [481] = {.entry = {.count = 1, .reusable = false}}, SHIFT(876), + [483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(877), + [485] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1752), + [487] = {.entry = {.count = 1, .reusable = false}}, SHIFT(878), + [489] = {.entry = {.count = 1, .reusable = false}}, SHIFT(211), + [491] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1175), + [493] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1417), + [495] = {.entry = {.count = 1, .reusable = false}}, SHIFT(617), + [497] = {.entry = {.count = 1, .reusable = false}}, SHIFT(330), + [499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(684), + [501] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1494), + [503] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1191), + [505] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1445), + [507] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1446), + [509] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1449), + [511] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1450), + [513] = {.entry = {.count = 1, .reusable = false}}, SHIFT(823), + [515] = {.entry = {.count = 1, .reusable = false}}, SHIFT(944), + [517] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1753), + [519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(883), + [521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(213), + [523] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1170), + [525] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1425), + [527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(689), + [529] = {.entry = {.count = 1, .reusable = false}}, SHIFT(333), + [531] = {.entry = {.count = 1, .reusable = false}}, SHIFT(340), + [533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(343), + [535] = {.entry = {.count = 1, .reusable = false}}, SHIFT(346), + [537] = {.entry = {.count = 1, .reusable = false}}, SHIFT(364), + [539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(640), + [541] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1391), + [543] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1190), + [545] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1371), + [547] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1372), + [549] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1373), + [551] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1374), + [553] = {.entry = {.count = 1, .reusable = false}}, SHIFT(926), + [555] = {.entry = {.count = 1, .reusable = false}}, SHIFT(927), + [557] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1760), + [559] = {.entry = {.count = 1, .reusable = false}}, SHIFT(349), + [561] = {.entry = {.count = 1, .reusable = false}}, SHIFT(928), + [563] = {.entry = {.count = 1, .reusable = false}}, SHIFT(227), + [565] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1174), + [567] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1481), + [569] = {.entry = {.count = 1, .reusable = false}}, SHIFT(641), + [571] = {.entry = {.count = 1, .reusable = false}}, SHIFT(352), + [573] = {.entry = {.count = 1, .reusable = false}}, SHIFT(355), + [575] = {.entry = {.count = 1, .reusable = false}}, SHIFT(358), + [577] = {.entry = {.count = 1, .reusable = false}}, SHIFT(361), + [579] = {.entry = {.count = 1, .reusable = false}}, SHIFT(362), + [581] = {.entry = {.count = 1, .reusable = false}}, SHIFT(365), + [583] = {.entry = {.count = 1, .reusable = false}}, SHIFT(368), + [585] = {.entry = {.count = 1, .reusable = false}}, SHIFT(372), + [587] = {.entry = {.count = 1, .reusable = false}}, SHIFT(374), + [589] = {.entry = {.count = 1, .reusable = false}}, SHIFT(294), + [591] = {.entry = {.count = 1, .reusable = false}}, SHIFT(297), + [593] = {.entry = {.count = 1, .reusable = false}}, SHIFT(370), + [595] = {.entry = {.count = 1, .reusable = false}}, SHIFT(300), + [597] = {.entry = {.count = 1, .reusable = false}}, SHIFT(301), + [599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(303), + [601] = {.entry = {.count = 1, .reusable = false}}, SHIFT(305), + [603] = {.entry = {.count = 1, .reusable = false}}, SHIFT(308), + [605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(309), + [607] = {.entry = {.count = 1, .reusable = false}}, SHIFT(310), + [609] = {.entry = {.count = 1, .reusable = false}}, SHIFT(313), + [611] = {.entry = {.count = 1, .reusable = false}}, SHIFT(315), + [613] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(484), + [616] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1357), + [619] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1181), + [622] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1246), + [625] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1247), + [628] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1248), + [631] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1250), + [634] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(869), + [637] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(870), + [640] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1751), + [643] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(871), + [646] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(209), + [649] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1176), + [652] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1538), + [655] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(485), + [658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(554), + [660] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1334), + [662] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1189), + [664] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1311), + [666] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1312), + [668] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1313), + [670] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1314), + [672] = {.entry = {.count = 1, .reusable = false}}, SHIFT(913), + [674] = {.entry = {.count = 1, .reusable = false}}, SHIFT(914), + [676] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_clause, 1, 0, 0), + [678] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1758), + [680] = {.entry = {.count = 1, .reusable = false}}, SHIFT(915), + [682] = {.entry = {.count = 1, .reusable = false}}, SHIFT(223), + [684] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1173), + [686] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1463), + [688] = {.entry = {.count = 1, .reusable = false}}, SHIFT(555), + [690] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(616), + [693] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1442), + [696] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1185), + [699] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1359), + [702] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1361), + [705] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1362), + [708] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1363), + [711] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(876), + [714] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(877), + [717] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1752), + [720] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(878), + [723] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(211), + [726] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1175), + [729] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1417), + [732] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(617), + [735] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(684), + [738] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1494), + [741] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1191), + [744] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1445), + [747] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1446), + [750] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1449), + [753] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1450), + [756] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(823), + [759] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(944), + [762] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1753), + [765] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(883), + [768] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(213), + [771] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1170), + [774] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1425), + [777] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(689), + [780] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(739), + [783] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1221), + [786] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1182), + [789] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1495), + [792] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1497), + [795] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1498), + [798] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1500), + [801] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(886), + [804] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(887), + [807] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1754), + [810] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(888), + [813] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(215), + [816] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1177), + [819] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1434), + [822] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(740), + [825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(302), + [827] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(821), + [830] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1284), + [833] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1188), + [836] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1251), + [839] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1252), + [842] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1253), + [845] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1254), + [848] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(899), + [851] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(900), + [854] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1756), + [857] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(901), + [860] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(219), + [863] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1171), + [866] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1447), + [869] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(492), + [872] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(509), + [875] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1310), + [878] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1184), + [881] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1286), + [884] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1287), + [887] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1288), + [890] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1289), + [893] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(906), + [896] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(907), + [899] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1757), + [902] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(908), + [905] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(221), + [908] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1178), + [911] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1456), + [914] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(510), + [917] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(554), + [920] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1334), + [923] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1189), + [926] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1311), + [929] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1312), + [932] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1313), + [935] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1314), + [938] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(913), + [941] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(914), + [944] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1758), + [947] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(915), + [950] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(223), + [953] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1173), + [956] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1463), + [959] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(555), + [962] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(640), + [965] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1391), + [968] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1190), + [971] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1371), + [974] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1372), + [977] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1373), + [980] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1374), + [983] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(926), + [986] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(927), + [989] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1760), + [992] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(928), + [995] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(227), + [998] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1174), + [1001] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1481), + [1004] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(641), + [1007] = {.entry = {.count = 1, .reusable = false}}, SHIFT(250), + [1009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), + [1011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1284), + [1013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1188), + [1015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1251), + [1017] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1252), + [1019] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1253), + [1021] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1254), + [1023] = {.entry = {.count = 1, .reusable = false}}, SHIFT(899), + [1025] = {.entry = {.count = 1, .reusable = false}}, SHIFT(900), + [1027] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1756), + [1029] = {.entry = {.count = 1, .reusable = false}}, SHIFT(901), + [1031] = {.entry = {.count = 1, .reusable = false}}, SHIFT(345), + [1033] = {.entry = {.count = 1, .reusable = false}}, SHIFT(219), + [1035] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1171), + [1037] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1447), + [1039] = {.entry = {.count = 1, .reusable = false}}, SHIFT(492), + [1041] = {.entry = {.count = 1, .reusable = false}}, SHIFT(810), + [1043] = {.entry = {.count = 1, .reusable = false}}, SHIFT(258), + [1045] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(746), + [1048] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1520), + [1051] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1179), + [1054] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1521), + [1057] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1522), + [1060] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1523), + [1063] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1524), + [1066] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(864), + [1069] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(865), + [1072] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1750), + [1075] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(866), + [1078] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(207), + [1081] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1168), + [1084] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(1398), + [1087] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat2, 2, 0, 0), SHIFT_REPEAT(752), + [1090] = {.entry = {.count = 1, .reusable = false}}, SHIFT(818), + [1092] = {.entry = {.count = 1, .reusable = false}}, SHIFT(480), + [1094] = {.entry = {.count = 1, .reusable = false}}, SHIFT(481), + [1096] = {.entry = {.count = 1, .reusable = false}}, SHIFT(482), + [1098] = {.entry = {.count = 1, .reusable = false}}, SHIFT(483), + [1100] = {.entry = {.count = 1, .reusable = false}}, SHIFT(264), + [1102] = {.entry = {.count = 1, .reusable = false}}, SHIFT(516), + [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(746), + [1106] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1520), + [1108] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1179), + [1110] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1521), + [1112] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1522), + [1114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1523), + [1116] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1524), + [1118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(864), + [1120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(865), + [1122] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1750), + [1124] = {.entry = {.count = 1, .reusable = false}}, SHIFT(866), + [1126] = {.entry = {.count = 1, .reusable = false}}, SHIFT(207), + [1128] = {.entry = {.count = 1, .reusable = false}}, SHIFT(882), + [1130] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1168), + [1132] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1398), + [1134] = {.entry = {.count = 1, .reusable = false}}, SHIFT(752), + [1136] = {.entry = {.count = 1, .reusable = false}}, SHIFT(232), + [1138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(562), + [1140] = {.entry = {.count = 1, .reusable = false}}, SHIFT(607), + [1142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(614), + [1144] = {.entry = {.count = 1, .reusable = false}}, SHIFT(615), + [1146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(268), + [1148] = {.entry = {.count = 1, .reusable = false}}, SHIFT(638), + [1150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(267), + [1152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(650), + [1154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(659), + [1156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(665), + [1158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(666), + [1160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(677), + [1162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(253), + [1164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(718), + [1166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(257), + [1168] = {.entry = {.count = 1, .reusable = false}}, SHIFT(357), + [1170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(726), + [1172] = {.entry = {.count = 1, .reusable = false}}, SHIFT(735), + [1174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(736), + [1176] = {.entry = {.count = 1, .reusable = false}}, SHIFT(737), + [1178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(738), + [1180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(255), + [1182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(762), + [1184] = {.entry = {.count = 1, .reusable = false}}, SHIFT(256), + [1186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(363), + [1188] = {.entry = {.count = 1, .reusable = false}}, SHIFT(771), + [1190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(780), + [1192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(781), + [1194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(782), + [1196] = {.entry = {.count = 1, .reusable = false}}, SHIFT(783), + [1198] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237), + [1200] = {.entry = {.count = 1, .reusable = false}}, SHIFT(403), + [1202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(235), + [1204] = {.entry = {.count = 1, .reusable = false}}, SHIFT(369), + [1206] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), + [1208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(419), + [1210] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), + [1212] = {.entry = {.count = 1, .reusable = false}}, SHIFT(421), + [1214] = {.entry = {.count = 1, .reusable = false}}, SHIFT(422), + [1216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), + [1218] = {.entry = {.count = 1, .reusable = false}}, SHIFT(488), + [1220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), + [1222] = {.entry = {.count = 1, .reusable = false}}, SHIFT(903), + [1224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(496), + [1226] = {.entry = {.count = 1, .reusable = false}}, SHIFT(505), + [1228] = {.entry = {.count = 1, .reusable = false}}, SHIFT(506), + [1230] = {.entry = {.count = 1, .reusable = false}}, SHIFT(507), + [1232] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), + [1234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(263), + [1236] = {.entry = {.count = 1, .reusable = false}}, SHIFT(532), + [1238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(249), + [1240] = {.entry = {.count = 1, .reusable = false}}, SHIFT(233), + [1242] = {.entry = {.count = 1, .reusable = false}}, SHIFT(541), + [1244] = {.entry = {.count = 1, .reusable = false}}, SHIFT(550), + [1246] = {.entry = {.count = 1, .reusable = false}}, SHIFT(551), + [1248] = {.entry = {.count = 1, .reusable = false}}, SHIFT(552), + [1250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(553), + [1252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(252), + [1254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(296), + [1256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(578), + [1258] = {.entry = {.count = 1, .reusable = false}}, SHIFT(254), + [1260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(587), + [1262] = {.entry = {.count = 1, .reusable = false}}, SHIFT(596), + [1264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(597), + [1266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(598), + [1268] = {.entry = {.count = 1, .reusable = false}}, SHIFT(599), + [1270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(239), + [1272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(394), + [1274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(238), + [1276] = {.entry = {.count = 1, .reusable = false}}, SHIFT(304), + [1278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(465), + [1280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(386), + [1282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), + [1284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(389), + [1286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(390), + [1288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), + [1290] = {.entry = {.count = 1, .reusable = false}}, SHIFT(662), + [1292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), + [1294] = {.entry = {.count = 1, .reusable = false}}, SHIFT(311), + [1296] = {.entry = {.count = 1, .reusable = false}}, SHIFT(671), + [1298] = {.entry = {.count = 1, .reusable = false}}, SHIFT(680), + [1300] = {.entry = {.count = 1, .reusable = false}}, SHIFT(681), + [1302] = {.entry = {.count = 1, .reusable = false}}, SHIFT(682), + [1304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(683), + [1306] = {.entry = {.count = 1, .reusable = false}}, SHIFT(830), + [1308] = {.entry = {.count = 1, .reusable = false}}, SHIFT(832), + [1310] = {.entry = {.count = 1, .reusable = false}}, SHIFT(833), + [1312] = {.entry = {.count = 1, .reusable = false}}, SHIFT(835), + [1314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(836), + [1316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(838), + [1318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(839), + [1320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(841), + [1322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(842), + [1324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(844), + [1326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(846), + [1328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(848), + [1330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(849), + [1332] = {.entry = {.count = 1, .reusable = false}}, SHIFT(851), + [1334] = {.entry = {.count = 1, .reusable = false}}, SHIFT(852), + [1336] = {.entry = {.count = 1, .reusable = false}}, SHIFT(854), + [1338] = {.entry = {.count = 1, .reusable = false}}, SHIFT(855), + [1340] = {.entry = {.count = 1, .reusable = false}}, SHIFT(857), + [1342] = {.entry = {.count = 1, .reusable = false}}, SHIFT(858), + [1344] = {.entry = {.count = 1, .reusable = false}}, SHIFT(860), + [1346] = {.entry = {.count = 1, .reusable = false}}, SHIFT(861), + [1348] = {.entry = {.count = 1, .reusable = false}}, SHIFT(863), + [1350] = {.entry = {.count = 1, .reusable = false}}, SHIFT(608), + [1352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string, 2, 0, 0), + [1354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string, 2, 0, 0), + [1356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string, 3, 0, 0), + [1358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string, 3, 0, 0), + [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), + [1362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), + [1364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(240), + [1366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [1368] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1265), + [1371] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1272), + [1374] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(240), + [1377] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), + [1379] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), + [1381] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1265), + [1384] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1272), + [1387] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(240), + [1390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), + [1392] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), + [1394] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(234), + [1397] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(234), + [1400] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1265), + [1403] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1272), + [1406] = {.entry = {.count = 1, .reusable = false}}, SHIFT(242), + [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [1410] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1255), + [1413] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1256), + [1416] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(242), + [1419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prefixed_identifier, 2, 0, 0), + [1421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prefixed_identifier, 2, 0, 0), + [1423] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1255), + [1426] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1256), + [1429] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(242), + [1432] = {.entry = {.count = 1, .reusable = false}}, SHIFT(243), + [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [1436] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1375), + [1439] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1376), + [1442] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(243), + [1445] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1375), + [1448] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1376), + [1451] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(243), + [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), + [1456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), + [1458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(234), + [1460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [1462] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1265), + [1465] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1272), + [1468] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(234), + [1471] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(241), + [1474] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(241), + [1477] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1255), + [1480] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1256), + [1483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(241), + [1485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [1487] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1255), + [1490] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1256), + [1493] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(241), + [1496] = {.entry = {.count = 1, .reusable = false}}, SHIFT(246), + [1498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [1500] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1375), + [1503] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1376), + [1506] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(246), + [1509] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_access, 4, 0, 0), + [1511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_access, 4, 0, 0), + [1513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [1515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [1517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_name, 1, 0, 0), + [1519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1274), + [1521] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(246), + [1524] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(246), + [1527] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1375), + [1530] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1376), + [1533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access, 3, 0, 0), + [1535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access, 3, 0, 0), + [1537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lvalue, 1, 0, 0), + [1539] = {.entry = {.count = 1, .reusable = false}}, SHIFT(271), + [1541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [1543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1315), + [1546] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1316), + [1549] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(271), + [1552] = {.entry = {.count = 1, .reusable = false}}, SHIFT(281), + [1554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [1556] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1364), + [1559] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1365), + [1562] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(281), + [1565] = {.entry = {.count = 1, .reusable = false}}, SHIFT(282), + [1567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1569] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1340), + [1572] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1341), + [1575] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(282), + [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(291), + [1580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [1582] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1501), + [1585] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1502), + [1588] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(291), + [1591] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1340), + [1594] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1341), + [1597] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(282), + [1600] = {.entry = {.count = 1, .reusable = false}}, SHIFT(285), + [1602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [1604] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1226), + [1607] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1227), + [1610] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(285), + [1613] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1226), + [1616] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1227), + [1619] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(285), + [1622] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1501), + [1625] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1502), + [1628] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(291), + [1631] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1364), + [1634] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1365), + [1637] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(281), + [1640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(279), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [1644] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1290), + [1647] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1291), + [1650] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(279), + [1653] = {.entry = {.count = 1, .reusable = false}}, SHIFT(275), + [1655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [1657] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1392), + [1660] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1393), + [1663] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(275), + [1666] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1392), + [1669] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1393), + [1672] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(275), + [1675] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1290), + [1678] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1291), + [1681] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(279), + [1684] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1315), + [1687] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1316), + [1690] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(271), + [1693] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), + [1695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [1697] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1428), + [1700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1429), + [1703] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(273), + [1706] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1428), + [1709] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1429), + [1712] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(273), + [1715] = {.entry = {.count = 1, .reusable = false}}, SHIFT(286), + [1717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [1719] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1451), + [1722] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(1453), + [1725] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 4, 0, 0), SHIFT(286), + [1728] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1451), + [1731] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(1453), + [1734] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_statement, 3, 0, 0), SHIFT(286), + [1737] = {.entry = {.count = 1, .reusable = false}}, SHIFT(276), + [1739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [1741] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1315), + [1744] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1316), + [1747] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(276), + [1750] = {.entry = {.count = 1, .reusable = false}}, SHIFT(274), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [1754] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1428), + [1757] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1429), + [1760] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(274), + [1763] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(274), + [1766] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(274), + [1769] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1428), + [1772] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1429), + [1775] = {.entry = {.count = 1, .reusable = false}}, SHIFT(277), + [1777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [1779] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1392), + [1782] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1393), + [1785] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(277), + [1788] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(276), + [1791] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(276), + [1794] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1315), + [1797] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1316), + [1800] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(277), + [1803] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(277), + [1806] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1392), + [1809] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1393), + [1812] = {.entry = {.count = 1, .reusable = false}}, SHIFT(289), + [1814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [1816] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1290), + [1819] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1291), + [1822] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(289), + [1825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(284), + [1827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [1829] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1364), + [1832] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1365), + [1835] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(284), + [1838] = {.entry = {.count = 1, .reusable = false}}, SHIFT(287), + [1840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [1842] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1340), + [1845] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1341), + [1848] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(287), + [1851] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(283), + [1854] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(283), + [1857] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1226), + [1860] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1227), + [1863] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(284), + [1866] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(284), + [1869] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1364), + [1872] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1365), + [1875] = {.entry = {.count = 1, .reusable = false}}, SHIFT(283), + [1877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [1879] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1226), + [1882] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1227), + [1885] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(283), + [1888] = {.entry = {.count = 1, .reusable = false}}, SHIFT(290), + [1890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [1892] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1451), + [1895] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1453), + [1898] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(290), + [1901] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(287), + [1904] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(287), + [1907] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1340), + [1910] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1341), + [1913] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(288), + [1916] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(288), + [1919] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1501), + [1922] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1502), + [1925] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(289), + [1928] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(289), + [1931] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1290), + [1934] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1291), + [1937] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(290), + [1940] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(290), + [1943] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1451), + [1946] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_region_name_repeat1, 2, 0, 0), SHIFT_REPEAT(1453), + [1949] = {.entry = {.count = 1, .reusable = false}}, SHIFT(288), + [1951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [1953] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1501), + [1956] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(1502), + [1959] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_region_name, 1, 0, 0), SHIFT(288), + [1962] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_temp_declaration, 3, 0, 0), + [1965] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_temp_declaration, 3, 0, 0), + [1968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_empty_statement, 1, 0, 0), + [1970] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_empty_statement, 1, 0, 0), + [1972] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 11, 0, 1), + [1974] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 11, 0, 1), + [1976] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), + [1978] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 5, 0, 0), + [1980] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(322), + [1983] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 5, 0, 0), + [1985] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 5, 0, 0), + [1987] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 11, 0, 1), + [1989] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 11, 0, 1), + [1991] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5, 0, 0), + [1993] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5, 0, 0), + [1995] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_region_statement, 5, 0, 0), + [1997] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_region_statement, 5, 0, 0), + [1999] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 11, 0, 0), + [2001] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 11, 0, 0), + [2003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 12, 0, 1), + [2005] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 12, 0, 1), + [2007] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 4, 0, 1), + [2009] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 4, 0, 1), + [2011] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 12, 0, 1), + [2013] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 12, 0, 1), + [2015] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 6, 0, 1), + [2017] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 6, 0, 1), + [2019] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 12, 0, 1), + [2021] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 12, 0, 1), + [2023] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 0), + [2025] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 0), + [2027] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 13, 0, 1), + [2029] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 13, 0, 1), + [2031] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 13, 0, 1), + [2033] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 13, 0, 1), + [2035] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 13, 0, 1), + [2037] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 13, 0, 1), + [2039] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 6, 0, 1), + [2041] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 6, 0, 1), + [2043] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_declaration, 2, 0, 0), + [2045] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_declaration, 2, 0, 0), + [2047] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 14, 0, 1), + [2049] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 14, 0, 1), + [2051] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 4, 0, 0), REDUCE(sym_var_constant_declaration, 4, 0, 0), + [2054] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 4, 0, 0), REDUCE(sym_var_constant_declaration, 4, 0, 0), + [2057] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 15, 0, 1), + [2059] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 15, 0, 1), + [2061] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 6, 0, 1), + [2063] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 6, 0, 1), + [2065] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 4, 0, 0), REDUCE(sym_var_retain_declaration, 4, 0, 0), + [2068] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 4, 0, 0), REDUCE(sym_var_retain_declaration, 4, 0, 0), + [2071] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 4, 0, 0), REDUCE(sym_var_non_retain_declaration, 4, 0, 0), + [2074] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 4, 0, 0), REDUCE(sym_var_non_retain_declaration, 4, 0, 0), + [2077] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 6, 0, 0), + [2079] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 6, 0, 0), + [2081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3, 0, 0), + [2083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3, 0, 0), + [2085] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 3, 0, 0), + [2087] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 3, 0, 0), + [2089] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), + [2091] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 6, 0, 0), + [2093] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4, 0, 0), + [2095] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4, 0, 0), + [2097] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(338), + [2100] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 6, 0, 0), + [2102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 6, 0, 0), + [2104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 7, 0, 1), + [2106] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 7, 0, 1), + [2108] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 0), + [2110] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 0), + [2112] = {.entry = {.count = 1, .reusable = false}}, SHIFT(826), + [2114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(827), + [2116] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), + [2118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), + [2120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), + [2122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, 0, 0), + [2124] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, 0, 0), + [2126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 7, 0, 1), + [2128] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 7, 0, 1), + [2130] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_temp_declaration, 2, 0, 0), + [2133] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_temp_declaration, 2, 0, 0), + [2136] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_constant_declaration, 2, 0, 0), + [2139] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_constant_declaration, 2, 0, 0), + [2142] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 7, 0, 1), + [2144] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 7, 0, 1), + [2146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 7, 0, 0), + [2148] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 7, 0, 0), + [2150] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 7, 0, 0), + [2152] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 7, 0, 0), + [2154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(930), + [2156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), + [2158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), + [2160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 8, 0, 1), + [2162] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 8, 0, 1), + [2164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 8, 0, 1), + [2166] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 8, 0, 1), + [2168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), + [2170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 4, 0, 0), + [2172] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(336), + [2175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while_statement, 4, 0, 0), + [2177] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while_statement, 4, 0, 0), + [2179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 8, 0, 1), + [2181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 8, 0, 1), + [2183] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_retain_declaration, 2, 0, 0), + [2186] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_retain_declaration, 2, 0, 0), + [2189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4, 0, 0), + [2191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4, 0, 0), + [2193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 8, 0, 0), + [2195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 8, 0, 0), + [2197] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_non_retain_declaration, 2, 0, 0), + [2200] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 2, 0, 0), REDUCE(sym_var_non_retain_declaration, 2, 0, 0), + [2203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 9, 0, 1), + [2205] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 9, 0, 1), + [2207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4, 0, 2), + [2209] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4, 0, 2), + [2211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 9, 0, 1), + [2213] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 9, 0, 1), + [2215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0), + [2217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0), + [2219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 5, 0, 1), + [2221] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 5, 0, 1), + [2223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 9, 0, 1), + [2225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 9, 0, 1), + [2227] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_declaration, 3, 0, 0), + [2229] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_declaration, 3, 0, 0), + [2231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 9, 0, 0), + [2233] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 9, 0, 0), + [2235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 10, 0, 1), + [2237] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 10, 0, 1), + [2239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 5, 0, 1), + [2241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 5, 0, 1), + [2243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 4, 0, 1), + [2245] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 4, 0, 1), + [2247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 10, 0, 1), + [2249] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 10, 0, 1), + [2251] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_constant_declaration, 3, 0, 0), + [2254] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_constant_declaration, 3, 0, 0), + [2257] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_retain_declaration, 3, 0, 0), + [2260] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_retain_declaration, 3, 0, 0), + [2263] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 10, 0, 1), + [2265] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 10, 0, 1), + [2267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 5, 0, 1), + [2269] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 5, 0, 1), + [2271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_block, 4, 0, 1), + [2273] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_block, 4, 0, 1), + [2275] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_non_retain_declaration, 3, 0, 0), + [2278] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_var_declaration, 3, 0, 0), REDUCE(sym_var_non_retain_declaration, 3, 0, 0), + [2281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 10, 0, 0), + [2283] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 10, 0, 0), + [2285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 0), + [2287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 0), + [2289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_organization_block, 11, 0, 1), + [2291] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_organization_block, 11, 0, 1), + [2293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(922), + [2295] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(385), + [2298] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(409), + [2301] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(415), + [2304] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(418), + [2307] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(381), + [2310] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(453), + [2313] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(478), + [2316] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(494), + [2319] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(500), + [2322] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(504), + [2325] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(535), + [2328] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(539), + [2331] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(545), + [2334] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(549), + [2337] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(571), + [2340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(585), + [2343] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(601), + [2346] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(591), + [2349] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(595), + [2352] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(647), + [2355] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(654), + [2358] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(658), + [2361] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(669), + [2364] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(675), + [2367] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(679), + [2370] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(724), + [2373] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(730), + [2376] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(734), + [2379] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(769), + [2382] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(775), + [2385] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 6, 0, 0), SHIFT(779), + [2388] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 4, 0, 0), SHIFT(816), + [2391] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_case_statement, 5, 0, 0), SHIFT(475), + [2394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(929), + [2396] = {.entry = {.count = 1, .reusable = false}}, SHIFT(896), + [2398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(929), + [2400] = {.entry = {.count = 1, .reusable = false}}, SHIFT(307), + [2402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), + [2404] = {.entry = {.count = 1, .reusable = false}}, SHIFT(248), + [2406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1668), + [2408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), + [2410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [2412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [2414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1579), + [2416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1245), + [2418] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1187), + [2420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1421), + [2422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [2424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), + [2426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1427), + [2428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), + [2430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1664), + [2432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1665), + [2434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [2436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), + [2438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1693), + [2440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [2442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), + [2444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [2446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), + [2450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 0), + [2452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), + [2454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(891), + [2456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [2458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), + [2460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [2462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(925), + [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [2466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), + [2468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [2470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1670), + [2472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [2474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), + [2476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), + [2478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [2480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1002), + [2482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [2484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [2486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), + [2488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [2490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), + [2492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [2494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), + [2496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [2498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), + [2500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [2502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1685), + [2504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [2506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [2508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), + [2510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [2512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(881), + [2514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [2516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), + [2518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [2520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [2522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1567), + [2524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(811), + [2526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(813), + [2528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), + [2530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), + [2532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(568), + [2536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), + [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), + [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(651), + [2542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(719), + [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), + [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), + [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(727), + [2550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1568), + [2552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), + [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), + [2556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1714), + [2558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1706), + [2560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [2562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), + [2564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1358), + [2566] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1186), + [2568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(772), + [2570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1728), + [2572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1649), + [2574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [2576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [2578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), + [2580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), + [2582] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(1245), + [2585] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(1187), + [2588] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(1421), + [2591] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(1422), + [2594] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(1424), + [2597] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(1427), + [2600] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2, 0, 0), SHIFT_REPEAT(991), + [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), + [2607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), + [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), + [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [2613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(533), + [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(537), + [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(542), + [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), + [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), + [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(583), + [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(588), + [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), + [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(441), + [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377), + [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), + [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), + [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), + [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), + [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(672), + [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [2651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1145), + [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), + [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), + [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [2669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [2671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), + [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [2677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), + [2681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [2687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1138), + [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [2691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [2695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1144), + [2697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), + [2701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1132), + [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), + [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [2729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), + [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [2733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [2737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1128), + [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [2741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [2743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), + [2745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), + [2747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [2749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), + [2751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [2753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), + [2755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [2757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), + [2759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), + [2761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), + [2763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), + [2765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), + [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), + [2769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), + [2771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(911), + [2773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), + [2775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), + [2777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), + [2779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1651), + [2781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [2783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1676), + [2785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [2787] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1, 0, 0), + [2789] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 1, 0, 0), + [2791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), + [2793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 8, 0, 0), + [2795] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 8, 0, 0), + [2797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), + [2799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [2801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), + [2803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [2805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), + [2807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [2809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1648), + [2811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [2813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 4, 0, 0), + [2815] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 4, 0, 0), + [2817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [2819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat1, 2, 0, 0), + [2821] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_organization_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1358), + [2824] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_organization_block_repeat1, 2, 0, 0), SHIFT_REPEAT(1186), + [2827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [2829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [2831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [2833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [2835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [2837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute_list, 5, 0, 0), + [2839] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_attribute_list, 5, 0, 0), + [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [2845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute_list, 4, 0, 0), + [2847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_attribute_list, 4, 0, 0), + [2849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute_list, 3, 0, 0), + [2851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_attribute_list, 3, 0, 0), + [2853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [2855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [2857] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), + [2859] = {.entry = {.count = 1, .reusable = false}}, SHIFT(295), + [2861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), + [2863] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1610), + [2865] = {.entry = {.count = 1, .reusable = false}}, SHIFT(637), + [2867] = {.entry = {.count = 1, .reusable = false}}, SHIFT(531), + [2869] = {.entry = {.count = 1, .reusable = false}}, SHIFT(717), + [2871] = {.entry = {.count = 1, .reusable = false}}, SHIFT(540), + [2873] = {.entry = {.count = 1, .reusable = false}}, SHIFT(661), + [2875] = {.entry = {.count = 1, .reusable = false}}, SHIFT(410), + [2877] = {.entry = {.count = 1, .reusable = false}}, SHIFT(670), + [2879] = {.entry = {.count = 1, .reusable = false}}, SHIFT(817), + [2881] = {.entry = {.count = 1, .reusable = false}}, SHIFT(487), + [2883] = {.entry = {.count = 1, .reusable = false}}, SHIFT(577), + [2885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(649), + [2887] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), + [2889] = {.entry = {.count = 1, .reusable = false}}, SHIFT(725), + [2891] = {.entry = {.count = 1, .reusable = false}}, SHIFT(761), + [2893] = {.entry = {.count = 1, .reusable = false}}, SHIFT(511), + [2895] = {.entry = {.count = 1, .reusable = false}}, SHIFT(495), + [2897] = {.entry = {.count = 1, .reusable = false}}, SHIFT(770), + [2899] = {.entry = {.count = 1, .reusable = false}}, SHIFT(402), + [2901] = {.entry = {.count = 1, .reusable = false}}, SHIFT(809), + [2903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(470), + [2905] = {.entry = {.count = 1, .reusable = false}}, SHIFT(561), + [2907] = {.entry = {.count = 1, .reusable = false}}, SHIFT(460), + [2909] = {.entry = {.count = 1, .reusable = false}}, SHIFT(586), + [2911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_declaration, 4, 0, 0), + [2913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_declaration, 4, 0, 0), + [2915] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_case_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(1658), + [2918] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_case_statement_repeat1, 2, 0, 0), + [2920] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_case_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(1570), + [2923] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_case_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(1610), + [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [2930] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1529), + [2932] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1530), + [2934] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1531), + [2936] = {.entry = {.count = 1, .reusable = false}}, SHIFT(753), + [2938] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1561), + [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1528), + [2942] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1325), + [2944] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1333), + [2946] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1360), + [2948] = {.entry = {.count = 1, .reusable = false}}, SHIFT(312), + [2950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), + [2952] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1219), + [2954] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1275), + [2956] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1277), + [2958] = {.entry = {.count = 1, .reusable = false}}, SHIFT(690), + [2960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1370), + [2962] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1504), + [2964] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1505), + [2966] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1506), + [2968] = {.entry = {.count = 1, .reusable = false}}, SHIFT(473), + [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1228), + [2972] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1558), + [2974] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1293), + [2976] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1294), + [2978] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1295), + [2980] = {.entry = {.count = 1, .reusable = false}}, SHIFT(602), + [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1317), + [2984] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1397), + [2986] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1400), + [2988] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1401), + [2990] = {.entry = {.count = 1, .reusable = false}}, SHIFT(741), + [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), + [2994] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1479), + [2996] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1156), + [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), + [3000] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1433), + [3002] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1436), + [3004] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1441), + [3006] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1162), + [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), + [3010] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1258), + [3012] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1259), + [3014] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1260), + [3016] = {.entry = {.count = 1, .reusable = false}}, SHIFT(556), + [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), + [3020] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1318), + [3022] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1319), + [3024] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1320), + [3026] = {.entry = {.count = 1, .reusable = false}}, SHIFT(642), + [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1342), + [3030] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1378), + [3032] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1379), + [3034] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1380), + [3036] = {.entry = {.count = 1, .reusable = false}}, SHIFT(702), + [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1394), + [3040] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1455), + [3042] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1458), + [3044] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1459), + [3046] = {.entry = {.count = 1, .reusable = false}}, SHIFT(785), + [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), + [3050] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1229), + [3052] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1230), + [3054] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1231), + [3056] = {.entry = {.count = 1, .reusable = false}}, SHIFT(444), + [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), + [3060] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1343), + [3062] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1344), + [3064] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1345), + [3066] = {.entry = {.count = 1, .reusable = false}}, SHIFT(459), + [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1377), + [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(668), + [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(824), + [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [3076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [3078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), + [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [3082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), + [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(570), + [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(653), + [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [3090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [3094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(590), + [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(544), + [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), + [3100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), + [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(774), + [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(646), + [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(729), + [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(538), + [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(445), + [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(584), + [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(768), + [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), + [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), + [3122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 0), + [3124] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(824), + [3127] = {.entry = {.count = 1, .reusable = false}}, SHIFT(627), + [3129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), + [3131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(804), + [3133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1366), + [3135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(423), + [3137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1232), + [3139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(471), + [3141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1233), + [3143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(425), + [3145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1234), + [3147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(426), + [3149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), + [3151] = {.entry = {.count = 1, .reusable = false}}, SHIFT(428), + [3153] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1237), + [3155] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), + [3157] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1238), + [3159] = {.entry = {.count = 1, .reusable = false}}, SHIFT(479), + [3161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(429), + [3163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1240), + [3165] = {.entry = {.count = 1, .reusable = false}}, SHIFT(430), + [3167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1241), + [3169] = {.entry = {.count = 1, .reusable = false}}, SHIFT(431), + [3171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), + [3173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(432), + [3175] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), + [3177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), + [3179] = {.entry = {.count = 1, .reusable = false}}, SHIFT(436), + [3181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1492), + [3183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1499), + [3185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(437), + [3187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), + [3189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(438), + [3191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(439), + [3193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(440), + [3195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1555), + [3197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1139), + [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), + [3201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(622), + [3203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [3205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(623), + [3207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), + [3209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(624), + [3211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), + [3213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(625), + [3215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), + [3217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(512), + [3219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), + [3221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(513), + [3223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), + [3225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(514), + [3227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), + [3229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(515), + [3231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), + [3233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(272), + [3235] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1266), + [3237] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1267), + [3239] = {.entry = {.count = 1, .reusable = false}}, SHIFT(447), + [3241] = {.entry = {.count = 1, .reusable = false}}, SHIFT(519), + [3243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [3245] = {.entry = {.count = 1, .reusable = false}}, SHIFT(520), + [3247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), + [3249] = {.entry = {.count = 1, .reusable = false}}, SHIFT(521), + [3251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), + [3253] = {.entry = {.count = 1, .reusable = false}}, SHIFT(522), + [3255] = {.entry = {.count = 1, .reusable = false}}, SHIFT(266), + [3257] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1282), + [3259] = {.entry = {.count = 1, .reusable = false}}, SHIFT(278), + [3261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), + [3263] = {.entry = {.count = 1, .reusable = false}}, SHIFT(527), + [3265] = {.entry = {.count = 1, .reusable = false}}, SHIFT(528), + [3267] = {.entry = {.count = 1, .reusable = false}}, SHIFT(529), + [3269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1283), + [3271] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1150), + [3273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [3275] = {.entry = {.count = 1, .reusable = false}}, SHIFT(628), + [3277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), + [3279] = {.entry = {.count = 1, .reusable = false}}, SHIFT(347), + [3281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), + [3283] = {.entry = {.count = 1, .reusable = false}}, SHIFT(629), + [3285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [3287] = {.entry = {.count = 1, .reusable = false}}, SHIFT(630), + [3289] = {.entry = {.count = 1, .reusable = false}}, SHIFT(269), + [3291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), + [3293] = {.entry = {.count = 1, .reusable = false}}, SHIFT(557), + [3295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1296), + [3297] = {.entry = {.count = 1, .reusable = false}}, SHIFT(558), + [3299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), + [3301] = {.entry = {.count = 1, .reusable = false}}, SHIFT(559), + [3303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1298), + [3305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(560), + [3307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), + [3309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(454), + [3311] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1301), + [3313] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1302), + [3315] = {.entry = {.count = 1, .reusable = false}}, SHIFT(563), + [3317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(564), + [3319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), + [3321] = {.entry = {.count = 1, .reusable = false}}, SHIFT(565), + [3323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), + [3325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(566), + [3327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), + [3329] = {.entry = {.count = 1, .reusable = false}}, SHIFT(567), + [3331] = {.entry = {.count = 1, .reusable = false}}, SHIFT(632), + [3333] = {.entry = {.count = 1, .reusable = false}}, SHIFT(458), + [3335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(572), + [3337] = {.entry = {.count = 1, .reusable = false}}, SHIFT(573), + [3339] = {.entry = {.count = 1, .reusable = false}}, SHIFT(574), + [3341] = {.entry = {.count = 1, .reusable = false}}, SHIFT(575), + [3343] = {.entry = {.count = 1, .reusable = false}}, SHIFT(634), + [3345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(635), + [3347] = {.entry = {.count = 1, .reusable = false}}, SHIFT(360), + [3349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(603), + [3351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1321), + [3353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(604), + [3355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1322), + [3357] = {.entry = {.count = 1, .reusable = false}}, SHIFT(605), + [3359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [3361] = {.entry = {.count = 1, .reusable = false}}, SHIFT(606), + [3363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), + [3365] = {.entry = {.count = 1, .reusable = false}}, SHIFT(464), + [3367] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1326), + [3369] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1327), + [3371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(609), + [3373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(610), + [3375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1329), + [3377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(611), + [3379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), + [3381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(612), + [3383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), + [3385] = {.entry = {.count = 1, .reusable = false}}, SHIFT(613), + [3387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(366), + [3389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), + [3391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(468), + [3393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), + [3395] = {.entry = {.count = 1, .reusable = false}}, SHIFT(619), + [3397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(620), + [3399] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), + [3401] = {.entry = {.count = 1, .reusable = false}}, SHIFT(231), + [3403] = {.entry = {.count = 1, .reusable = false}}, SHIFT(367), + [3405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), + [3407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [3409] = {.entry = {.count = 1, .reusable = false}}, SHIFT(392), + [3411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), + [3413] = {.entry = {.count = 1, .reusable = false}}, SHIFT(395), + [3415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1347), + [3417] = {.entry = {.count = 1, .reusable = false}}, SHIFT(397), + [3419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), + [3421] = {.entry = {.count = 1, .reusable = false}}, SHIFT(398), + [3423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1349), + [3425] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), + [3427] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1351), + [3429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1352), + [3431] = {.entry = {.count = 1, .reusable = false}}, SHIFT(648), + [3433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(427), + [3435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1354), + [3437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(433), + [3439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), + [3441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(434), + [3443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1356), + [3445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(435), + [3447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), + [3449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1118), + [3451] = {.entry = {.count = 1, .reusable = false}}, SHIFT(446), + [3453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), + [3455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(449), + [3457] = {.entry = {.count = 1, .reusable = false}}, SHIFT(450), + [3459] = {.entry = {.count = 1, .reusable = false}}, SHIFT(451), + [3461] = {.entry = {.count = 1, .reusable = false}}, SHIFT(695), + [3463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), + [3465] = {.entry = {.count = 1, .reusable = false}}, SHIFT(371), + [3467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [3469] = {.entry = {.count = 1, .reusable = false}}, SHIFT(703), + [3471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), + [3473] = {.entry = {.count = 1, .reusable = false}}, SHIFT(705), + [3475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1407), + [3477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(706), + [3479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), + [3481] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), + [3483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1411), + [3485] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1412), + [3487] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_var_declaration_repeat1, 2, 0, 0), + [3489] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_var_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1561), + [3492] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_var_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1366), + [3495] = {.entry = {.count = 1, .reusable = false}}, SHIFT(351), + [3497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1452), + [3499] = {.entry = {.count = 1, .reusable = false}}, SHIFT(314), + [3501] = {.entry = {.count = 1, .reusable = false}}, SHIFT(707), + [3503] = {.entry = {.count = 1, .reusable = false}}, SHIFT(685), + [3505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1381), + [3507] = {.entry = {.count = 1, .reusable = false}}, SHIFT(686), + [3509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1382), + [3511] = {.entry = {.count = 1, .reusable = false}}, SHIFT(687), + [3513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [3515] = {.entry = {.count = 1, .reusable = false}}, SHIFT(688), + [3517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1384), + [3519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(270), + [3521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1385), + [3523] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1386), + [3525] = {.entry = {.count = 1, .reusable = false}}, SHIFT(463), + [3527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(691), + [3529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1388), + [3531] = {.entry = {.count = 1, .reusable = false}}, SHIFT(692), + [3533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1389), + [3535] = {.entry = {.count = 1, .reusable = false}}, SHIFT(693), + [3537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1390), + [3539] = {.entry = {.count = 1, .reusable = false}}, SHIFT(694), + [3541] = {.entry = {.count = 1, .reusable = false}}, SHIFT(280), + [3543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(696), + [3545] = {.entry = {.count = 1, .reusable = false}}, SHIFT(697), + [3547] = {.entry = {.count = 1, .reusable = false}}, SHIFT(698), + [3549] = {.entry = {.count = 1, .reusable = false}}, SHIFT(699), + [3551] = {.entry = {.count = 1, .reusable = false}}, SHIFT(466), + [3553] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1395), + [3555] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1396), + [3557] = {.entry = {.count = 1, .reusable = false}}, SHIFT(704), + [3559] = {.entry = {.count = 1, .reusable = false}}, SHIFT(467), + [3561] = {.entry = {.count = 1, .reusable = false}}, SHIFT(708), + [3563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), + [3565] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1484), + [3567] = {.entry = {.count = 1, .reusable = false}}, SHIFT(709), + [3569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1415), + [3571] = {.entry = {.count = 1, .reusable = false}}, SHIFT(710), + [3573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1416), + [3575] = {.entry = {.count = 1, .reusable = false}}, SHIFT(711), + [3577] = {.entry = {.count = 1, .reusable = false}}, SHIFT(292), + [3579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), + [3581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), + [3583] = {.entry = {.count = 1, .reusable = false}}, SHIFT(317), + [3585] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1090), + [3587] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1285), + [3589] = {.entry = {.count = 1, .reusable = false}}, SHIFT(384), + [3591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(712), + [3593] = {.entry = {.count = 1, .reusable = false}}, SHIFT(713), + [3595] = {.entry = {.count = 1, .reusable = false}}, SHIFT(714), + [3597] = {.entry = {.count = 1, .reusable = false}}, SHIFT(715), + [3599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1413), + [3601] = {.entry = {.count = 1, .reusable = false}}, SHIFT(331), + [3603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), + [3605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(806), + [3607] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1153), + [3609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), + [3611] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1157), + [3613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), + [3615] = {.entry = {.count = 1, .reusable = false}}, SHIFT(318), + [3617] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1152), + [3619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), + [3621] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1469), + [3623] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1151), + [3625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1477), + [3627] = {.entry = {.count = 1, .reusable = false}}, SHIFT(452), + [3629] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1480), + [3631] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1483), + [3633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1564), + [3635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1116), + [3637] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1154), + [3639] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1155), + [3641] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1158), + [3643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1485), + [3645] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1513), + [3647] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1159), + [3649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), + [3651] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1239), + [3653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(947), + [3655] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1160), + [3657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), + [3659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1161), + [3661] = {.entry = {.count = 1, .reusable = false}}, SHIFT(742), + [3663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1460), + [3665] = {.entry = {.count = 1, .reusable = false}}, SHIFT(743), + [3667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), + [3669] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1268), + [3671] = {.entry = {.count = 1, .reusable = false}}, SHIFT(744), + [3673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), + [3675] = {.entry = {.count = 1, .reusable = false}}, SHIFT(745), + [3677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), + [3679] = {.entry = {.count = 1, .reusable = false}}, SHIFT(387), + [3681] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1467), + [3683] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1468), + [3685] = {.entry = {.count = 1, .reusable = false}}, SHIFT(747), + [3687] = {.entry = {.count = 1, .reusable = false}}, SHIFT(748), + [3689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), + [3691] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1303), + [3693] = {.entry = {.count = 1, .reusable = false}}, SHIFT(749), + [3695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), + [3697] = {.entry = {.count = 1, .reusable = false}}, SHIFT(750), + [3699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [3701] = {.entry = {.count = 1, .reusable = false}}, SHIFT(751), + [3703] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1328), + [3705] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [3707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), + [3709] = {.entry = {.count = 1, .reusable = false}}, SHIFT(757), + [3711] = {.entry = {.count = 1, .reusable = false}}, SHIFT(758), + [3713] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1353), + [3715] = {.entry = {.count = 1, .reusable = false}}, SHIFT(759), + [3717] = {.entry = {.count = 1, .reusable = false}}, SHIFT(230), + [3719] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1493), + [3721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), + [3723] = {.entry = {.count = 1, .reusable = false}}, SHIFT(457), + [3725] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1387), + [3727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), + [3729] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1165), + [3731] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1164), + [3733] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1163), + [3735] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1332), + [3737] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1335), + [3739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), + [3741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), + [3743] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1578), + [3746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), + [3748] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_repeat1, 2, 0, 0), + [3750] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_repeat1, 2, 0, 0), SHIFT_REPEAT(1492), + [3753] = {.entry = {.count = 1, .reusable = false}}, SHIFT(786), + [3755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1507), + [3757] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_attribute_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1585), + [3760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_attribute_list_repeat1, 2, 0, 0), + [3762] = {.entry = {.count = 1, .reusable = false}}, SHIFT(787), + [3764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), + [3766] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), + [3768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), + [3770] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_repeat2, 2, 0, 0), + [3772] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_repeat2, 2, 0, 0), SHIFT_REPEAT(1499), + [3775] = {.entry = {.count = 1, .reusable = false}}, SHIFT(789), + [3777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1510), + [3779] = {.entry = {.count = 1, .reusable = false}}, SHIFT(396), + [3781] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1511), + [3783] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1512), + [3785] = {.entry = {.count = 1, .reusable = false}}, SHIFT(792), + [3787] = {.entry = {.count = 1, .reusable = false}}, SHIFT(793), + [3789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1514), + [3791] = {.entry = {.count = 1, .reusable = false}}, SHIFT(794), + [3793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1516), + [3795] = {.entry = {.count = 1, .reusable = false}}, SHIFT(795), + [3797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), + [3799] = {.entry = {.count = 1, .reusable = false}}, SHIFT(796), + [3801] = {.entry = {.count = 1, .reusable = false}}, SHIFT(400), + [3803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(800), + [3805] = {.entry = {.count = 1, .reusable = false}}, SHIFT(801), + [3807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), + [3809] = {.entry = {.count = 1, .reusable = false}}, SHIFT(802), + [3811] = {.entry = {.count = 1, .reusable = false}}, SHIFT(803), + [3813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(948), + [3815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), + [3817] = {.entry = {.count = 1, .reusable = false}}, SHIFT(754), + [3819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), + [3821] = {.entry = {.count = 1, .reusable = false}}, SHIFT(755), + [3823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), + [3825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(765), + [3827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), + [3829] = {.entry = {.count = 1, .reusable = false}}, SHIFT(784), + [3831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1535), + [3833] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1091), + [3835] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1537), + [3837] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1408), + [3839] = {.entry = {.count = 1, .reusable = false}}, SHIFT(805), + [3841] = {.entry = {.count = 1, .reusable = false}}, SHIFT(790), + [3843] = {.entry = {.count = 1, .reusable = false}}, SHIFT(791), + [3845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1220), + [3847] = {.entry = {.count = 1, .reusable = false}}, SHIFT(797), + [3849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1527), + [3851] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), + [3853] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), + [3855] = {.entry = {.count = 1, .reusable = false}}, SHIFT(799), + [3857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), + [3859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), + [3861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1547), + [3863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1599), + [3865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(834), + [3867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(859), + [3869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), + [3871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(847), + [3873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [3875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [3877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), + [3879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), + [3881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), + [3883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), + [3885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), + [3887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [3889] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute_value, 1, 0, 0), + [3891] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_attribute, 3, 0, 0), + [3893] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [3895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [3897] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), + [3899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [3901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1573), + [3903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), + [3905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_item, 6, 0, 3), + [3907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_item, 6, 0, 3), + [3909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_item, 7, 0, 4), + [3911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_item, 7, 0, 4), + [3913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1638), + [3915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), + [3917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [3919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1635), + [3921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1624), + [3923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(700), + [3925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1609), + [3927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(626), + [3929] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_item, 4, 0, 3), + [3931] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_item, 4, 0, 3), + [3933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1709), + [3935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), + [3937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1593), + [3939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), + [3941] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1666), + [3943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(536), + [3945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1608), + [3947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), + [3949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1597), + [3951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(582), + [3953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1691), + [3955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(721), + [3957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1594), + [3959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(644), + [3961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1600), + [3963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(353), + [3965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1621), + [3967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), + [3969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), + [3971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [3973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1732), + [3975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), + [3977] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_var_item, 5, 0, 4), + [3979] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_var_item, 5, 0, 4), + [3981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1644), + [3983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1100), + [3985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), + [3987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1695), + [3989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(649), + [3991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1183), + [3993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), + [3995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [3997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(701), + [3999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1650), + [4001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [4003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), + [4005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), + [4007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [4009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1629), + [4011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [4013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), + [4015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), + [4017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1698), + [4019] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_range, 3, 0, 0), + [4021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), + [4023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1663), + [4025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1736), + [4027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), + [4029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1602), + [4031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(655), + [4033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(382), + [4035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), + [4037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [4039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1645), + [4041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [4043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), + [4045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1707), + [4047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), + [4049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1667), + [4051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), + [4053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1678), + [4055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), + [4057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(778), + [4059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), + [4061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), + [4063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), + [4065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), + [4067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [4069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1717), + [4071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1595), + [4073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), + [4075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1697), + [4077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1114), + [4079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(579), + [4081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1731), + [4083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), + [4085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [4087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1761), + [4089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(581), + [4091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1660), + [4093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(540), + [4095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1699), + [4097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), + [4099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1701), + [4101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), + [4103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), + [4105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1440), + [4107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), + [4109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1703), + [4111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(600), + [4113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [4115] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [4117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1681), + [4119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443), + [4121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1581), + [4123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(586), + [4125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), + [4127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), + [4129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), + [4131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(503), + [4133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1606), + [4135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(725), + [4137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), + [4139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(592), + [4141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), + [4143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [4145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1694), + [4147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [4149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(593), + [4151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), + [4153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), + [4155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [4157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1712), + [4159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), + [4161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), + [4163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1003), + [4165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), + [4167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(732), + [4169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), + [4171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1117), + [4173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1700), + [4175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), + [4177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [4179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1605), + [4181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), + [4183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1519), + [4185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1632), + [4187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1109), + [4189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [4191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [4193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(817), + [4195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [4197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(561), + [4199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [4201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), + [4203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1244), + [4205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(546), + [4207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1120), + [4209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [4211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), + [4213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [4215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(456), + [4217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(678), + [4219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [4221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1727), + [4223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), + [4225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [4227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(936), + [4229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [4231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(938), + [4233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), + [4235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(940), + [4237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), + [4239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(942), + [4241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(943), + [4243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1738), + [4245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1740), + [4247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), + [4249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [4251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), + [4253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1744), + [4255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1745), + [4257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1746), + [4259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1747), + [4261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1748), + [4263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), + [4265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1013), +}; + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef TREE_SITTER_HIDE_SYMBOLS +#define TS_PUBLIC +#elif defined(_WIN32) +#define TS_PUBLIC __declspec(dllexport) +#else +#define TS_PUBLIC __attribute__((visibility("default"))) +#endif + +TS_PUBLIC const TSLanguage *tree_sitter_scl(void) { + static const TSLanguage language = { + .abi_version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .supertype_count = SUPERTYPE_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = ts_field_map_slices, + .field_map_entries = ts_field_map_entries, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = (const void*)ts_lex_modes, + .lex_fn = ts_lex, + .primary_state_ids = ts_primary_state_ids, + .name = "scl", + .max_reserved_word_set_size = 0, + .metadata = { + .major_version = 0, + .minor_version = 1, + .patch_version = 0, + }, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/src/parser.lua b/src/parser.lua new file mode 100644 index 0000000..6f03b63 --- /dev/null +++ b/src/parser.lua @@ -0,0 +1,267 @@ +-- SCL Parser utilities for the LSP server +local M = {} + +function M.extract_variables(content) + local variables = {} + local variable_positions = {} + + local lines = {} + for line in content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + local in_var_section = false + local var_type = "unknown" + local current_block = nil + + local function process_line(line, line_num) + local trimmed = line:gsub("^%s+", ""):gsub("%s+$", "") + + -- Detect block start + local fb_name = trimmed:match('FUNCTION_BLOCK%s+"([^"]+)"') + if fb_name then + current_block = { name = fb_name, kind = "function_block" } + in_var_section = false + return + end + + local ob_name = trimmed:match('ORGANIZATION_BLOCK%s+"([^"]+)"') + if ob_name then + current_block = { name = ob_name, kind = "organization_block" } + in_var_section = false + return + end + + local fn_name = trimmed:match('FUNCTION%s+"([^"]+)"') + if fn_name then + current_block = { name = fn_name, kind = "function" } + in_var_section = false + return + end + + if trimmed:match("^END_FUNCTION_BLOCK") or + trimmed:match("^END_ORGANIZATION_BLOCK") or + trimmed:match("^END_FUNCTION") then + current_block = nil + in_var_section = false + return + end + + if trimmed:match("^VAR[_A-Z]*%s*$") or + trimmed:match("^VAR_INPUT%s*$") or + trimmed:match("^VAR_OUTPUT%s*$") or + trimmed:match("^VAR_IN_OUT%s*$") or + trimmed:match("^VAR_TEMP%s*$") or + trimmed:match("^VAR[_ ]*CONSTANT%s*$") or + trimmed:match("^VAR[_ ]*RETAIN%s*$") or + trimmed:match("^VAR[_ ]*NON_RETAIN%s*$") then + in_var_section = true + if trimmed:match("INPUT") then var_type = "VAR_INPUT" + elseif trimmed:match("OUTPUT") then var_type = "VAR_OUTPUT" + elseif trimmed:match("IN_OUT") then var_type = "VAR_IN_OUT" + elseif trimmed:match("TEMP") then var_type = "VAR_TEMP" + elseif trimmed:match("CONSTANT") then var_type = "VAR_CONSTANT" + elseif trimmed:match("RETAIN") then var_type = "VAR_RETAIN" + elseif trimmed:match("NON_RETAIN") then var_type = "VAR_NON_RETAIN" + else var_type = "VAR" end + return + end + + if trimmed:match("^END_VAR%s*$") then + in_var_section = false + return + end + + if not in_var_section then return end + + if trimmed:match("^%(%*") or trimmed:match("^%s*//") then + return + end + + local var_name = trimmed:match("^([%w_]+)%s*:") + if not var_name then + var_name = trimmed:match("^([%w_]+)%s*,") + end + + if var_name and not variables[var_name] then + local col = line:find(var_name, 1, true) + if col then + local type_start = line:find(":", 1, true) + local var_data_type = "unknown" + if type_start then + local type_part = line:sub(type_start + 1) + type_part = type_part:gsub("%s*:=.*$", "") + type_part = type_part:gsub("%s*;.*$", "") + type_part = type_part:gsub("^%s+", "") + type_part = type_part:gsub("%s+$", "") + var_data_type = type_part + end + + variables[var_name] = { + type = var_type, + data_type = var_data_type, + line = line_num, + character = col - 1, + } + variable_positions[var_name] = { + line = line_num, + character = col - 1, + } + end + end + end + + for i, line in ipairs(lines) do + process_line(line, i - 1) + end + + return variables, variable_positions +end + +function M.extract_types(content) + local types = {} + + local lines = {} + for line in content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + local in_type_section = false + local current_type = nil + local brace_depth = 0 + + for i, line in ipairs(lines) do + local trimmed = line:gsub("^%s+", ""):gsub("%s+$", "") + + if trimmed:match("^TYPE$") or trimmed:match("^TYPE%s+:=") then + in_type_section = true + brace_depth = 0 + elseif in_type_section and trimmed:match("^END_TYPE") then + in_type_section = false + current_type = nil + elseif in_type_section then + local type_name = trimmed:match("^(%w+):") + if type_name then + local struct_start = trimmed:find("{") + local array_match = trimmed:find("ARRAY") + + if struct_start then + current_type = { + name = type_name, + kind = "struct", + fields = {}, + start_line = i - 1, + } + types[type_name] = current_type + elseif array_match then + local of_type = trimmed:match("OF%s+(%w+)") + if of_type then + current_type = { + name = type_name, + kind = "array", + element_type = of_type, + start_line = i - 1, + } + types[type_name] = current_type + end + else + local field_type = trimmed:match(":%s*(%w+)") + if field_type then + current_type = { + name = type_name, + kind = "alias", + base_type = field_type, + start_line = i - 1, + } + types[type_name] = current_type + end + end + end + + if current_type and current_type.kind == "struct" then + for open in line:gmatch("{") do brace_depth = brace_depth + 1 end + for close in line:gmatch("}") do brace_depth = brace_depth - 1 end + + local field_name = line:match("^%s*(%w+):") + if field_name and field_name ~= current_type.name then + local field_type = line:match(":%s*(%w+)") + table.insert(current_type.fields, { + name = field_name, + type = field_type or "unknown", + }) + end + + if brace_depth == 0 then + current_type = nil + end + end + end + end + + return types +end + +function M.extract_functions(content) + local functions = {} + + local lines = {} + for line in content:gmatch("([^\n]*)\n") do + table.insert(lines, line) + end + + local function find_block_end(start_line, block_name, end_markers) + local depth = 1 + for i = start_line + 1, #lines do + local line = lines[i] + if line:match("^%s*" .. block_name) then + depth = depth + 1 + end + for _, marker in ipairs(end_markers) do + if line:match("^%s*" .. marker) then + depth = depth - 1 + if depth == 0 then return i end + end + end + end + return #lines + end + + for i, line in ipairs(lines) do + local func_name = line:match('FUNCTION%s+"([^"]+)"') + if func_name then + local end_line = find_block_end(i, "END_FUNCTION", { "END_FUNCTION" }) + table.insert(functions, { + name = func_name, + kind = "function", + start = i - 1, + final = end_line - 1, + }) + end + + local fb_name = line:match('FUNCTION_BLOCK%s+"([^"]+)"') + if fb_name then + local end_line = find_block_end(i, "END_FUNCTION_BLOCK", { "END_FUNCTION_BLOCK" }) + table.insert(functions, { + name = fb_name, + kind = "function_block", + start = i - 1, + final = end_line - 1, + }) + end + + local ob_name = line:match('ORGANIZATION_BLOCK%s+"([^"]+)"') + if ob_name then + local end_line = find_block_end(i, "END_ORGANIZATION_BLOCK", { "END_ORGANIZATION_BLOCK" }) + table.insert(functions, { + name = ob_name, + kind = "organization_block", + start = i - 1, + final = end_line - 1, + }) + end + end + + return functions +end + +return M diff --git a/src/plc_json.lua b/src/plc_json.lua new file mode 100644 index 0000000..433f41a --- /dev/null +++ b/src/plc_json.lua @@ -0,0 +1,268 @@ +-- Load UDT types from external .plc.json files +-- Auto-generate from data_types folder + +local M = {} + +local cached_types = {} + +local function run_command(cmd) + local handle = io.popen(cmd) + if not handle then return nil end + local result = handle:read("*a") + handle:close() + return result +end + +local script_path = debug.getinfo(1, "S").source:gsub("^@", ""):match("(.*/)") or "" +if script_path == "" then script_path = "." end + +local cwd = io.popen("pwd"):read("*l") +if script_path:sub(1, 1) == "/" then + script_path = script_path:gsub("/+$", "") +elseif cwd then + script_path = cwd .. "/" .. script_path + script_path = script_path:gsub("/+", "/"):gsub("/$", "") +else + script_path = "." +end + +local function load_json(content) + local json = dofile(script_path .. "/json.lua") + local ok, data = pcall(function() return json.decode(content) end) + if ok then return data end + return nil +end + +local function scan_files_recursive(dir, pattern) + local files = {} + local result = run_command("find " .. dir .. " -type f -name \"" .. pattern .. "\" 2>/dev/null") + if result then + for f in result:gmatch("[^\n]+") do + if f ~= "" then table.insert(files, f) end + end + end + return files +end + +local function parse_plc_type(dt) + local type_name = dt.name or dt.Name or dt.baseType or dt.dataTypeName + if not type_name then return nil end + + local typ = { + name = type_name, + kind = "alias", + fields = {}, + source = "external", + } + + if dt.struct or dt.member or dt.members or dt.elements then + typ.kind = "struct" + local members = dt.struct or dt.member or dt.members or dt.elements + if type(members) == "table" then + for _, m in ipairs(members) do + local field_name = m.name or m.Name + local field_type = m.dataTypeName or m.baseType or m.type or m.dataType or "unknown" + if field_name then + table.insert(typ.fields, { + name = field_name, + type = field_type, + }) + end + end + end + elseif dt.baseType or dt.baseTypeName then + typ.kind = "alias" + typ.base_type = dt.baseType or dt.baseTypeName + end + + return typ +end + +local function parse_scl_type_file(content) + local types = {} + local in_type = false + local in_struct = false + local current_type_name = nil + local pending_type_name = nil + + local lines = {} + for line in content:gmatch("[^\n]+") do table.insert(lines, line) end + + for i, line in ipairs(lines) do + local trimmed = line:gsub("^%s+", ""):gsub("%s+$", "") + + if trimmed:match("^TYPE%s*:?%s*$") then + in_type = true + in_struct = false + current_type_name = nil + pending_type_name = nil + elseif trimmed:match("^END_TYPE") then + in_type = false + in_struct = false + current_type_name = nil + pending_type_name = nil + elseif in_type then + if trimmed:match("^END_STRUCT") then + in_struct = false + current_type_name = nil + pending_type_name = nil + elseif trimmed:match("^STRUCT") then + if pending_type_name then + current_type_name = pending_type_name + in_struct = true + types[pending_type_name] = { name = pending_type_name, kind = "struct", fields = {}, source = "data_types_folder" } + pending_type_name = nil + end + elseif not in_struct and trimmed:match("^%w+%s*:") and not trimmed:match("^STRUCT") then + local type_name = trimmed:match("^(%w+)%s*:") + if type_name then + local next_line = lines[i + 1] + local next_trimmed = next_line and next_line:gsub("^%s+", ""):gsub("%s+$", "") + if next_trimmed and next_trimmed:match("^STRUCT") then + pending_type_name = type_name + else + pending_type_name = nil + current_type_name = nil + in_struct = false + local base_type = trimmed:match(":%s*([%w_]+)") + types[type_name] = { name = type_name, kind = "alias", base_type = base_type or "UNKNOWN", source = "data_types_folder" } + end + end + elseif in_struct and current_type_name and types[current_type_name] then + local field_name = line:match("^%s*(%w+)%s*:") + if field_name and field_name ~= "END_STRUCT" then + local field_type = line:match(":%s*([%w_]+)") + table.insert(types[current_type_name].fields, { + name = field_name, + type = field_type or "unknown", + }) + end + end + end + end + + return types +end + +function M.load_types_from_workspace(root_dir) + local types = {} + + if not root_dir or root_dir == "" then return types end + + -- Scan for .plc.json files + local plc_files = scan_files_recursive(root_dir, "*.plc.json") + for _, filepath in ipairs(plc_files) do + local content = run_command("cat " .. filepath:gsub(" ", "\\ ")) + if content then + local data = load_json(content) + if data and (data.dataTypes or data.DataTypes or data.types or data.Types) then + local typeList = data.dataTypes or data.DataTypes or data.types or data.Types + for _, dt in ipairs(typeList) do + local typ = parse_plc_type(dt) + if typ and not types[typ.name] then + types[typ.name] = typ + end + end + end + end + end + + -- Scan for plc.data.json files + local plc_data_files = scan_files_recursive(root_dir, "plc.data.json") + for _, filepath in ipairs(plc_data_files) do + local content = run_command("cat " .. filepath:gsub(" ", "\\ ")) + if content then + local data = load_json(content) + if data and (data.dataTypes or data.DataTypes) then + for _, dt in ipairs(data.dataTypes or data.DataTypes) do + local typ = parse_plc_type(dt) + if typ and not types[typ.name] then + types[typ.name] = typ + end + end + end + end + end + + -- Auto-generate from data_types folder (SCL files) + local data_types_files = scan_files_recursive(root_dir, "*.scl") + for _, filepath in ipairs(data_types_files) do + local content = run_command("cat " .. filepath:gsub(" ", "\\ ")) + if content then + local scl_types = parse_scl_type_file(content) + for name, typ in pairs(scl_types) do + if not types[name] then + types[name] = typ + end + end + end + end + + return types +end + +function M.get_types(root_dir) + if not root_dir or root_dir == "" then + root_dir = "workspace" + end + + if cached_types[root_dir] then + return cached_types[root_dir] + end + + local types = M.load_types_from_workspace(root_dir) + cached_types[root_dir] = types + return types +end + +function M.generate_plc_json(root_dir, output_file) + local json = dofile(script_path .. "/json.lua") + + if not root_dir or root_dir == "" then return false end + + local types = M.load_types_from_workspace(root_dir) + + local dataTypes = {} + for _, typ in pairs(types) do + if typ.kind == "struct" then + local members = {} + for _, field in ipairs(typ.fields) do + table.insert(members, { + name = field.name, + dataTypeName = field.type, + }) + end + table.insert(dataTypes, { + name = typ.name, + struct = members, + }) + elseif typ.kind == "alias" then + table.insert(dataTypes, { + name = typ.name, + baseType = typ.base_type or "UNKNOWN", + }) + end + end + + local output = { + plcProject = { + dataTypes = dataTypes, + }, + } + + local content = json.encode(output) + local file = io.open(output_file, "w") + if file then + file:write(content) + file:close() + return true + end + + return false +end + +function M.clear_cache() + cached_types = {} +end + +return M diff --git a/src/tree_sitter/alloc.h b/src/tree_sitter/alloc.h new file mode 100644 index 0000000..1abdd12 --- /dev/null +++ b/src/tree_sitter/alloc.h @@ -0,0 +1,54 @@ +#ifndef TREE_SITTER_ALLOC_H_ +#define TREE_SITTER_ALLOC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +// Allow clients to override allocation functions +#ifdef TREE_SITTER_REUSE_ALLOCATOR + +extern void *(*ts_current_malloc)(size_t size); +extern void *(*ts_current_calloc)(size_t count, size_t size); +extern void *(*ts_current_realloc)(void *ptr, size_t size); +extern void (*ts_current_free)(void *ptr); + +#ifndef ts_malloc +#define ts_malloc ts_current_malloc +#endif +#ifndef ts_calloc +#define ts_calloc ts_current_calloc +#endif +#ifndef ts_realloc +#define ts_realloc ts_current_realloc +#endif +#ifndef ts_free +#define ts_free ts_current_free +#endif + +#else + +#ifndef ts_malloc +#define ts_malloc malloc +#endif +#ifndef ts_calloc +#define ts_calloc calloc +#endif +#ifndef ts_realloc +#define ts_realloc realloc +#endif +#ifndef ts_free +#define ts_free free +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ALLOC_H_ diff --git a/src/tree_sitter/array.h b/src/tree_sitter/array.h new file mode 100644 index 0000000..e99918e --- /dev/null +++ b/src/tree_sitter/array.h @@ -0,0 +1,347 @@ +#ifndef TREE_SITTER_ARRAY_H_ +#define TREE_SITTER_ARRAY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "./alloc.h" + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4101) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif + +#define Array(T) \ + struct { \ + T *contents; \ + uint32_t size; \ + uint32_t capacity; \ + } + +/// Initialize an array. +#define array_init(self) \ + ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL) + +/// Create an empty array. +#define array_new() \ + { NULL, 0, 0 } + +/// Get a pointer to the element at a given `index` in the array. +#define array_get(self, _index) \ + (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index]) + +/// Get a pointer to the first element in the array. +#define array_front(self) array_get(self, 0) + +/// Get a pointer to the last element in the array. +#define array_back(self) array_get(self, (self)->size - 1) + +/// Clear the array, setting its size to zero. Note that this does not free any +/// memory allocated for the array's contents. +#define array_clear(self) ((self)->size = 0) + +/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is +/// less than the array's current capacity, this function has no effect. +#define array_reserve(self, new_capacity) \ + ((self)->contents = _array__reserve( \ + (void *)(self)->contents, &(self)->capacity, \ + array_elem_size(self), new_capacity) \ + ) + +/// Free any memory allocated for this array. Note that this does not free any +/// memory allocated for the array's contents. +#define array_delete(self) _array__delete((self), (void *)(self)->contents, sizeof(*self)) + +/// Push a new `element` onto the end of the array. +#define array_push(self, element) \ + do { \ + (self)->contents = _array__grow( \ + (void *)(self)->contents, (self)->size, &(self)->capacity, \ + 1, array_elem_size(self) \ + ); \ + (self)->contents[(self)->size++] = (element); \ + } while(0) + +/// Increase the array's size by `count` elements. +/// New elements are zero-initialized. +#define array_grow_by(self, count) \ + do { \ + if ((count) == 0) break; \ + (self)->contents = _array__grow( \ + (self)->contents, (self)->size, &(self)->capacity, \ + count, array_elem_size(self) \ + ); \ + memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \ + (self)->size += (count); \ + } while (0) + +/// Append all elements from one array to the end of another. +#define array_push_all(self, other) \ + array_extend((self), (other)->size, (other)->contents) + +/// Append `count` elements to the end of the array, reading their values from the +/// `contents` pointer. +#define array_extend(self, count, other_contents) \ + (self)->contents = _array__splice( \ + (void*)(self)->contents, &(self)->size, &(self)->capacity, \ + array_elem_size(self), (self)->size, 0, count, other_contents \ + ) + +/// Remove `old_count` elements from the array starting at the given `index`. At +/// the same index, insert `new_count` new elements, reading their values from the +/// `new_contents` pointer. +#define array_splice(self, _index, old_count, new_count, new_contents) \ + (self)->contents = _array__splice( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + array_elem_size(self), _index, old_count, new_count, new_contents \ + ) + +/// Insert one `element` into the array at the given `index`. +#define array_insert(self, _index, element) \ + (self)->contents = _array__splice( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + array_elem_size(self), _index, 0, 1, &(element) \ + ) + +/// Remove one element from the array at the given `index`. +#define array_erase(self, _index) \ + _array__erase((void *)(self)->contents, &(self)->size, array_elem_size(self), _index) + +/// Pop the last element off the array, returning the element by value. +#define array_pop(self) ((self)->contents[--(self)->size]) + +/// Assign the contents of one array to another, reallocating if necessary. +#define array_assign(self, other) \ + (self)->contents = _array__assign( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + (const void *)(other)->contents, (other)->size, array_elem_size(self) \ + ) + +/// Swap one array with another +#define array_swap(self, other) \ + do { \ + struct Swap swapped_contents = _array__swap( \ + (void *)(self)->contents, &(self)->size, &(self)->capacity, \ + (void *)(other)->contents, &(other)->size, &(other)->capacity \ + ); \ + (self)->contents = swapped_contents.self_contents; \ + (other)->contents = swapped_contents.other_contents; \ + } while (0) + +/// Get the size of the array contents +#define array_elem_size(self) (sizeof *(self)->contents) + +/// Search a sorted array for a given `needle` value, using the given `compare` +/// callback to determine the order. +/// +/// If an existing element is found to be equal to `needle`, then the `index` +/// out-parameter is set to the existing value's index, and the `exists` +/// out-parameter is set to true. Otherwise, `index` is set to an index where +/// `needle` should be inserted in order to preserve the sorting, and `exists` +/// is set to false. +#define array_search_sorted_with(self, compare, needle, _index, _exists) \ + _array__search_sorted(self, 0, compare, , needle, _index, _exists) + +/// Search a sorted array for a given `needle` value, using integer comparisons +/// of a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_with`. +#define array_search_sorted_by(self, field, needle, _index, _exists) \ + _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists) + +/// Insert a given `value` into a sorted array, using the given `compare` +/// callback to determine the order. +#define array_insert_sorted_with(self, compare, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_with(self, compare, &(value), &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +/// Insert a given `value` into a sorted array, using integer comparisons of +/// a given struct field (specified with a leading dot) to determine the order. +/// +/// See also `array_search_sorted_by`. +#define array_insert_sorted_by(self, field, value) \ + do { \ + unsigned _index, _exists; \ + array_search_sorted_by(self, field, (value) field, &_index, &_exists); \ + if (!_exists) array_insert(self, _index, value); \ + } while (0) + +// Private + +// Pointers to individual `Array` fields (rather than the entire `Array` itself) +// are passed to the various `_array__*` functions below to address strict aliasing +// violations that arises when the _entire_ `Array` struct is passed as `Array(void)*`. +// +// The `Array` type itself was not altered as a solution in order to avoid breakage +// with existing consumers (in particular, parsers with external scanners). + +/// This is not what you're looking for, see `array_delete`. +static inline void _array__delete(void *self, void *contents, size_t self_size) { + if (contents) ts_free(contents); + if (self) memset(self, 0, self_size); +} + +/// This is not what you're looking for, see `array_erase`. +static inline void _array__erase(void* self_contents, uint32_t *size, + size_t element_size, uint32_t index) { + assert(index < *size); + char *contents = (char *)self_contents; + memmove(contents + index * element_size, contents + (index + 1) * element_size, + (*size - index - 1) * element_size); + (*size)--; +} + +/// This is not what you're looking for, see `array_reserve`. +static inline void *_array__reserve(void *contents, uint32_t *capacity, + size_t element_size, uint32_t new_capacity) { + void *new_contents = contents; + if (new_capacity > *capacity) { + if (contents) { + new_contents = ts_realloc(contents, new_capacity * element_size); + } else { + new_contents = ts_malloc(new_capacity * element_size); + } + *capacity = new_capacity; + } + return new_contents; +} + +/// This is not what you're looking for, see `array_assign`. +static inline void *_array__assign(void* self_contents, uint32_t *self_size, uint32_t *self_capacity, + const void *other_contents, uint32_t other_size, size_t element_size) { + void *new_contents = _array__reserve(self_contents, self_capacity, element_size, other_size); + *self_size = other_size; + memcpy(new_contents, other_contents, *self_size * element_size); + return new_contents; +} + +struct Swap { + void *self_contents; + void *other_contents; +}; + +/// This is not what you're looking for, see `array_swap`. +// static inline void _array__swap(Array *self, Array *other) { +static inline struct Swap _array__swap(void *self_contents, uint32_t *self_size, uint32_t *self_capacity, + void *other_contents, uint32_t *other_size, uint32_t *other_capacity) { + void *new_self_contents = other_contents; + uint32_t new_self_size = *other_size; + uint32_t new_self_capacity = *other_capacity; + + void *new_other_contents = self_contents; + *other_size = *self_size; + *other_capacity = *self_capacity; + + *self_size = new_self_size; + *self_capacity = new_self_capacity; + + struct Swap out = { + .self_contents = new_self_contents, + .other_contents = new_other_contents, + }; + return out; +} + +/// This is not what you're looking for, see `array_push` or `array_grow_by`. +static inline void *_array__grow(void *contents, uint32_t size, uint32_t *capacity, + uint32_t count, size_t element_size) { + void *new_contents = contents; + uint32_t new_size = size + count; + if (new_size > *capacity) { + uint32_t new_capacity = *capacity * 2; + if (new_capacity < 8) new_capacity = 8; + if (new_capacity < new_size) new_capacity = new_size; + new_contents = _array__reserve(contents, capacity, element_size, new_capacity); + } + return new_contents; +} + +/// This is not what you're looking for, see `array_splice`. +static inline void *_array__splice(void *self_contents, uint32_t *size, uint32_t *capacity, + size_t element_size, + uint32_t index, uint32_t old_count, + uint32_t new_count, const void *elements) { + uint32_t new_size = *size + new_count - old_count; + uint32_t old_end = index + old_count; + uint32_t new_end = index + new_count; + assert(old_end <= *size); + + void *new_contents = _array__reserve(self_contents, capacity, element_size, new_size); + + char *contents = (char *)new_contents; + if (*size > old_end) { + memmove( + contents + new_end * element_size, + contents + old_end * element_size, + (*size - old_end) * element_size + ); + } + if (new_count > 0) { + if (elements) { + memcpy( + (contents + index * element_size), + elements, + new_count * element_size + ); + } else { + memset( + (contents + index * element_size), + 0, + new_count * element_size + ); + } + } + *size += new_count - old_count; + + return new_contents; +} + +/// A binary search routine, based on Rust's `std::slice::binary_search_by`. +/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`. +#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \ + do { \ + *(_index) = start; \ + *(_exists) = false; \ + uint32_t size = (self)->size - *(_index); \ + if (size == 0) break; \ + int comparison; \ + while (size > 1) { \ + uint32_t half_size = size / 2; \ + uint32_t mid_index = *(_index) + half_size; \ + comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \ + if (comparison <= 0) *(_index) = mid_index; \ + size -= half_size; \ + } \ + comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \ + if (comparison == 0) *(_exists) = true; \ + else if (comparison < 0) *(_index) += 1; \ + } while (0) + +/// Helper macro for the `_sorted_by` routines below. This takes the left (existing) +/// parameter by reference in order to work with the generic sorting function above. +#define _compare_int(a, b) ((int)*(a) - (int)(b)) + +#ifdef _MSC_VER +#pragma warning(pop) +#elif defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_ARRAY_H_ diff --git a/src/tree_sitter/parser.h b/src/tree_sitter/parser.h new file mode 100644 index 0000000..858107d --- /dev/null +++ b/src/tree_sitter/parser.h @@ -0,0 +1,286 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSStateId; +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +typedef struct TSLanguageMetadata { + uint8_t major_version; + uint8_t minor_version; + uint8_t patch_version; +} TSLanguageMetadata; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +// Used to index the field and supertype maps. +typedef struct { + uint16_t index; + uint16_t length; +} TSMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); + void (*log)(const TSLexer *, const char *, ...); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; + uint16_t reserved_word_set_id; +} TSLexerMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +typedef struct { + int32_t start; + int32_t end; +} TSCharacterRange; + +struct TSLanguage { + uint32_t abi_version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char * const *symbol_names; + const char * const *field_names; + const TSMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexerMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; + const TSStateId *primary_state_ids; + const char *name; + const TSSymbol *reserved_words; + uint16_t max_reserved_word_set_size; + uint32_t supertype_count; + const TSSymbol *supertype_symbols; + const TSMapSlice *supertype_map_slices; + const TSSymbol *supertype_map_entries; + TSLanguageMetadata metadata; +}; + +static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) { + uint32_t index = 0; + uint32_t size = len - index; + while (size > 1) { + uint32_t half_size = size / 2; + uint32_t mid_index = index + half_size; + const TSCharacterRange *range = &ranges[mid_index]; + if (lookahead >= range->start && lookahead <= range->end) { + return true; + } else if (lookahead > range->end) { + index = mid_index; + } + size -= half_size; + } + const TSCharacterRange *range = &ranges[index]; + return (lookahead >= range->start && lookahead <= range->end); +} + +/* + * Lexer Macros + */ + +#ifdef _MSC_VER +#define UNUSED __pragma(warning(suppress : 4101)) +#else +#define UNUSED __attribute__((unused)) +#endif + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + UNUSED \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define ADVANCE_MAP(...) \ + { \ + static const uint16_t map[] = { __VA_ARGS__ }; \ + for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) { \ + if (map[i] == lookahead) { \ + state = map[i + 1]; \ + goto next_state; \ + } \ + } \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT) + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value) \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = (state_value), \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_name, children, precedence, prod_id) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_name, \ + .child_count = children, \ + .dynamic_precedence = precedence, \ + .production_id = prod_id \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ diff --git a/src/treesitter.lua b/src/treesitter.lua new file mode 100644 index 0000000..e2d2f04 --- /dev/null +++ b/src/treesitter.lua @@ -0,0 +1,149 @@ +-- Tree-sitter integration for SCL LSP +-- Uses tree-sitter to parse SCL files more accurately + +local M = {} + +local ts = nil + +function M.init() + local ok, treesitter = pcall(require, "vim.treesitter") + if ok then + ts = treesitter + return true + end + return false +end + +function M.parse_scl(content) + if not ts then + return nil, "Tree-sitter not available" + end + + local ok, parser = pcall(ts.get_parser, 0, "scl") + if not ok or not parser then + return nil, "SCL parser not available" + end + + local tree = parser:parse_string(content) + if not tree then + return nil, "Failed to parse content" + end + + return tree, nil +end + +function M.extract_variables_ts(tree, bufnr) + local variables = {} + local variable_positions = {} + + if not tree or not ts then return variables, variable_positions end + + local root = tree:root() + + local var_types = { + var_declaration = "VAR", + var_input_declaration = "VAR_INPUT", + var_output_declaration = "VAR_OUTPUT", + var_in_out_declaration = "VAR_IN_OUT", + var_temp_declaration = "VAR_TEMP", + var_constant_declaration = "VAR_CONSTANT", + var_retain_declaration = "VAR_RETAIN", + var_non_retain_declaration = "VAR_NON_RETAIN", + } + + for node_type, var_type in pairs(var_types) do + for node in root:iter_descendants_of_type(node_type) do + local var_item = node:child_by_field_name("item") + if var_item then + local name_node = var_item:child_by_field_name("name") + if name_node then + local start_row, start_col, end_row, end_col = name_node:range() + local name = ts.get_node_text(name_node, bufnr) + + if name and not variables[name] then + variables[name] = { + type = var_type, + line = start_row, + character = start_col, + } + variable_positions[name] = { + line = start_row, + character = start_col, + } + end + end + end + end + end + + return variables, variable_positions +end + +function M.extract_functions_ts(tree, bufnr) + local functions = {} + + if not tree or not ts then return functions end + + local root = tree:root() + + local function extract_block(block_type, kind) + for node in root:iter_descendants_of_type(block_type) do + local name_node = node:child_by_field_name("name") + if name_node then + local start_row, start_col, end_row, end_col = node:range() + local name = ts.get_node_text(name_node, bufnr) + table.insert(functions, { + name = name, + kind = kind, + start = start_row, + final = end_row, + }) + end + end + end + + extract_block("function", "function") + extract_block("function_block", "function_block") + extract_block("organization_block", "organization_block") + + return functions +end + +function M.get_node_at_position(tree, row, col) + if not tree then return nil end + + local root = tree:root() + for node in root:iter_descendants() do + local start_row, start_col, end_row, end_col = node:range() + if start_row <= row and end_row >= row then + if start_col <= col and end_col >= col then + return node + end + end + end + return nil +end + +function M.get_variable_type_at_cursor(tree, bufnr, row, col) + if not tree or not ts then return nil end + + local node = M.get_node_at_position(tree, row, col) + if not node then return nil end + + local node_type = node:type() + + if node_type == "identifier" then + local parent = node:parent() + if parent and parent:type() == "prefixed_identifier" then + local name = ts.get_node_text(node, bufnr) + local vars, _ = M.extract_variables_ts(tree, bufnr) + if vars and vars[name] then + return vars[name].type + end + end + end + + return nil +end + +return M diff --git a/tree-sitter.json b/tree-sitter.json new file mode 100644 index 0000000..a8dc872 --- /dev/null +++ b/tree-sitter.json @@ -0,0 +1,32 @@ +{ + "grammars": [ + { + "name": "scl", + "camelcase": "SCL", + "scope": "source.scl", + "path": ".", + "file-types": [ + "scl" + ], + "highlights": "queries/highlights.scm" + } + ], + "metadata": { + "version": "0.1.0", + "license": "MIT", + "description": "Siemens Structured Control Language (SCL) grammar for tree-sitter", + "authors": [ + { + "name": "L-TECH" + } + ], + "links": { + "repository": "https://github.com/l-techno/tree-sitter-scl" + } + }, + "bindings": { + "c": true, + "node": true, + "rust": false + } +} \ No newline at end of file